Konfigurowanie środowiska


Często konieczna jest dodatkowa konfiguracja funkcji, np. klucze interfejsu API innej firmy czy ustawienia z możliwością dostosowania. Pakiet SDK Firebase dla Cloud Functions ma wbudowaną konfigurację środowiska, która ułatwia przechowywanie i pobieranie danych tego typu na potrzeby projektu.

Masz do wyboru 3 opcje:

  • Konfiguracja z parametrami (zalecana w większości scenariuszy). Zapewnia to ściśle wpisaną konfigurację środowiska z parametrami weryfikowanymi podczas wdrażania, co zapobiega błędom i upraszcza debugowanie.
  • Konfiguracja zmiennych środowiskowych na podstawie plików. Ta metoda pozwala na ręczne utworzenie pliku dotenv do wczytywania zmiennych środowiskowych.
  • Konfiguracja środowiska środowiska wykonawczego z interfejsem wiersza poleceń Firebase i functions.config (tylko Cloud Functions (1 generacji)).

W większości przypadków zalecana jest konfiguracja z parametrami. Dzięki temu wartości konfiguracji są dostępne zarówno w czasie działania, jak i w czasie wdrażania, a wdrażanie jest blokowane, chyba że wszystkie parametry mają prawidłową wartość. Natomiast konfiguracja ze zmiennymi środowiskowymi jest niedostępna podczas wdrażania.

Konfiguracja z parametrami

Cloud Functions dla Firebase ma interfejs do deklaratywnego definiowania parametrów konfiguracyjnych w bazie kodu. Wartości tych parametrów są dostępne zarówno podczas wdrażania funkcji, ustawiania opcji wdrażania i środowiska wykonawczego, 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, stosuj się do poniższego 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 konfiguracji 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 jest ustawiony żaden default, interfejs wiersza poleceń poprosi o podanie wartości podczas wdrażania, a następnie automatycznie zapisze wartości w pliku .env o nazwie .env.<project_ID> w katalogu functions/:

$ firebase deploy
i  functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i  functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i  functions: Loaded environment variables from .env.projectId

W zależności od przepływu pracy programisty 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 staną się rzeczywistymi wartościami. Oznacza to, że pobieranie wartości parametrów z zakresu globalnego kończy się niepowodzeniem wdrożenia. W przypadkach, gdy chcesz użyć parametru do zainicjowania wartości globalnej, użyj wywołania zwrotnego onInit(). To wywołanie zwrotne jest uruchamiane przed uruchomieniem funkcji w środowisku produkcyjnym, ale nie jest wywoływane podczas wdrażania, dlatego stanowi bezpieczne miejsce, aby uzyskać dostęp 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 steruje sposobem, w jaki interfejs wiersza poleceń ma prosić o wartości. Poniższy przykład przedstawia opcje weryfikacji formatu numeru telefonu, udostępniania prostej opcji wyboru oraz automatycznego wypełniania opcji wyboru z poziomu 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 szybkie wpisywanie wartości parametrów oraz obsługuje 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 podczas wdrażania, jak i podczas wykonywania funkcji. Ze względu na te podwójne środowiska należy zachować pewną ostrożność podczas porównywania wartości parametrów oraz używania ich do ustawiania opcji czasu działania 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, jeśli chcesz porównać z jakimś parametrem, którą opcję wybrać, musisz użyć wbudowanych komparatorów, 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) => {
    //…

Dostęp do parametrów i wyrażeń parametrów używanych tylko w czasie działania można uzyskać 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.`);
  }
);

Wbudowane parametry

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 ta funkcja.
  • databaseURL – adres URL instancji Bazy danych czasu rzeczywistego powiązanej z funkcją (jeśli została włączona w projekcie Firebase).
  • storageBucket – zasobnik Cloud Storage powiązany z funkcją (jeśli włączono tę funkcję w projekcie Firebase).

Działają one jak parametry w postaci zdefiniowane przez użytkownika pod każdym względem. Jedyna różnica jest taka, że ich wartości są zawsze znane interfejsowi wiersza poleceń Firebase, więc ich wartości nie będą wyświetlane przy wdrożeniu ani zapisywane w plikach .env.

Parametry obiektu tajnego

Parametry typu Secret, zdefiniowane za pomocą defineSecret(), reprezentują parametry w postaci ciągu znaków, które mają wartość zapisaną w usłudze Cloud Secret Manager. Zamiast sprawdzać lokalny plik .env i zapisywać nową wartość w pliku w przypadku jego braku, parametry obiektu tajnego sprawdzają, czy istnieje on w usłudze Cloud Secret Manager, i podczas wdrażania wyświetlają interaktywne pytanie o wartość nowego obiektu tajnego.

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');
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żesz 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ć w interfejsie 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 klucze. 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 zbiorów zmiennych środowiskowych

Jeśli potrzebujesz alternatywnego zestawu zmiennych środowiskowych dla projektów Firebase (np. testowego lub produkcyjnego), utwórz plik .env.<project or alias> i zapisz w nim zmienne środowiskowe swojego projektu. Zmienne środowiskowe z .env i związane z projektem pliki .env (jeśli istnieją) zostaną uwzględnione we wszystkich wdrożonych funkcjach.

Projekt może np. zawierać te 3 pliki, które mają nieco inne wartości dotyczące programowania i produkcji:

.env .env.dev .env.prod
PLANET=Ziemia

AUDIENCE=ludzie

AUDIENCE=Programiści AUDIENCE=Produkcy ludzie

Biorąc pod uwagę wartości w tych osobnych plikach, zbiór zmiennych środowiskowych wdrożonych za pomocą 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 żadnego z tych kluczy w plikach .env:

  • Wszystkie klucze zaczynają się od X_GOOGLE_
  • Wszystkie klucze 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
  • TOŻSAMOŚĆ_FUNKCJI
  • REGION_FUNKCJI
  • FUNCTION_TARGET
  • FUNCTION_SIGNATURE_TYPE
  • K_SERVICE
  • K_REVISION
  • PORT
  • K_KONFIGURACJA

Przechowywanie poufnych informacji o konfiguracji i uzyskiwanie do nich dostępu

Zmienne środowiskowe zapisane w plikach .env mogą służyć do konfigurowania funkcji, ale nie należy ich traktować jako bezpiecznego sposobu przechowywania informacji poufnych, takich jak dane logowania do bazy danych czy klucze interfejsu API. Jest to szczególnie ważne, jeśli sprawdzasz pliki .env w kontroli źródeł.

Aby ułatwić przechowywanie poufnych informacji o konfiguracji, platforma Cloud Functions dla Firebase jest zintegrowana z usługą Google Cloud Secret Manager. Ta zaszyfrowana usługa bezpiecznie przechowuje wartości konfiguracji, ale w razie potrzeby umożliwia ł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 z niego korzystać:

  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ń odczytuje komunikat o powodzeniu i ostrzega o konieczności wdrożenia funkcji, 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. Wdróż funkcje w Cloud Functions:

    firebase deploy --only functions

Będzie można z niej korzystać tak samo jak do wszystkich innych zmiennych środowiskowych. I odwrotnie, jeśli inna funkcja, która nie określa obiektu tajnego w runWith, próbuje uzyskać dostęp do tego obiektu tajnego, otrzymuje niezdefiniowaną wartość:

  exports.anotherEndpoint = functions.https.onRequest((request, response) => {
    response.send(`The secret API key is ${process.env.SECRET_NAME}`);
    // responds with "The secret API key is undefined" because the `runWith` parameter is missing
  });

Po wdrożeniu funkcja będzie miała dostęp do wartości obiektu tajnego. Tylko funkcje, które w parametrze runWith zawierają obiekt tajny, będą miały do niego dostęp jako zmienną środowiskową. Dzięki temu masz pewność, że wartości obiektów tajnych są dostępne tylko wtedy, gdy są potrzebne, co zmniejsza ryzyko przypadkowego wycieku obiektu tajnego.

Zarządzanie obiektami tajnymi

Używaj interfejsu wiersza poleceń Firebase do zarządzania obiektami tajnymi. 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. Więcej szczegółów:

  • Po ustawieniu nowej wartości obiektu tajnego należy ponownie wdrożyć wszystkie funkcje, które się do niego odwołują, aby pobrać najnowszą wartość.
  • Jeśli usuniesz obiekt tajny, żadna z wdrożonych funkcji nie będzie się do niego odwoływać. Funkcje korzystające z usuniętej wartości obiektu tajnego przestaną działać w trybie dyskretnym.

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 poleceniach access i destroy możesz podać opcjonalny parametr wersji, 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, aby wyświetlić pomoc interfejsu wiersza poleceń.

Jak są naliczane opłaty za obiekty tajne

Usługa Secret Manager zezwala na 6 aktywnych wersji obiektów tajnych bez ponoszenia opłat. Oznacza to, że w projekcie Firebase możesz mieć 6 obiektów tajnych miesięcznie bez ponoszenia opłat.

Domyślnie interfejs wiersza poleceń Firebase próbuje automatycznie niszczyć nieużywane wersje obiektu tajnego, gdy jest to potrzebne, na przykład podczas wdrażania funkcji z nową wersją obiektu tajnego. Możesz też aktywnie czyścić nieużywane obiekty tajne za pomocą functions:secrets:destroy i functions:secrets:prune.

Usługa Secret Manager umożliwia 10 000 nierozliczonych miesięcznych operacji dostępu do obiektu tajnego. Instancje funkcji odczytują tylko obiekty tajne określone w parametrze runWith przy każdym uruchomieniu „na zimno”. Jeśli masz wiele instancji funkcji odczytujących wiele obiektów tajnych, Twój projekt może przekroczyć ten limit.Pobierzemy wówczas opłatę w wysokości 0,03 USD za 10 000 operacji dostępu.

Więcej informacji znajdziesz w cenniku usługi Secret Manager.

Obsługa emulatora

Konfiguracja środowiska przy użyciu Dotenv jest przeznaczona do współpracy z lokalnym emulatorem Cloud Functions.

Jeśli używasz lokalnego emulatora Cloud Functions, możesz zastąpić zmienne środowiskowe w projekcie, konfigurując plik .env.local. Zawartość pliku .env.local ma pierwszeństwo przed .env oraz plikiem .env konkretnego projektu.

Projekt może np. zawierać te 3 pliki zawierające nieco inne wartości na potrzeby testów programistycznych 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 obsługuje korzystanie z obiektów tajnych do przechowywania poufnych informacji o konfiguracji i uzyskiwania do nich dostępu. Domyślnie emulator będzie próbował uzyskać dostęp do produkcyjnych obiektów tajnych za pomocą domyślnych danych logowania aplikacji. W niektórych sytuacjach, na przykład w środowiskach CI, emulator może nie uzyskać dostępu do wartości obiektów tajnych z powodu ograniczeń uprawnień.

Podobnie jak w przypadku obsługi zmiennych środowiskowych w emulatorze Cloud Functions możesz zastąpić wartości obiektów tajnych, konfigurując plik .secret.local. Ułatwia to lokalne testowanie funkcji, 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 zawiera polecenie eksportu, które zwraca konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc Twojego katalogu (w przykładzie poniżej local, dev i prod) w postaci plików .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 pojawi się prośba o wpisanie prefiksu umożliwiającego zmianę nazwy wyeksportowanych kluczy zmiennych środowiskowych. Dzieje się tak, ponieważ nie wszystkie konfiguracje można przekształcić automatycznie, ponieważ mogą być nieprawidłowe lub mogą być zarezerwowanymi kluczami zmiennej środowiskowej.

Zalecamy dokładne sprawdzenie zawartości wygenerowanych plików .env przed wdrożeniem funkcji lub sprawdzeniem plików .env w kontroli źródła. Jeśli jakiekolwiek wartości są poufne i nie powinny zostać ujawnione, usuń je z plików .env i przechowuj je bezpiecznie w usłudze Secret Manager.

Trzeba też zaktualizować kod funkcji. Wszystkie funkcje, które używają functions.config, będą teraz musiały używać interfejsu process.env, jak pokazano w sekcji Przechodzenie na wersję 2 generacji.

Konfiguracja środowiska

Przed wprowadzeniem obsługi zmiennych środowiskowych w firebase-functions v3.18.0 korzystanie z interfejsu functions.config() było zalecanym sposobem konfigurowania środowiska. Ta metoda jest nadal obsługiwana, ale zalecamy, aby we wszystkich nowych projektach używać zmiennych środowiskowych, ponieważ są one łatwiejsze w użyciu i zwiększają przenośność 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 umieścić w przestrzeni nazw za pomocą kropek, aby grupować powiązane konfiguracje. Pamiętaj, że w kluczach akceptowane są tylko małe litery, a wielkie litery są niedozwolone.

Aby np. zapisać identyfikator klienta i klucz interfejsu API dla „jakiejś usługi”, możesz uruchomić ten skrypt:

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 Twojego projektu, możesz użyć firebase functions:config:get. Zwrócony wynik JSON będzie podobny do tego:

{
  "someservice": {
    "key":"THE API KEY",
    "id":"THE CLIENT ID"
  }
}

Ta funkcja jest oparta na interfejsie Google Cloud Runtime Configuration API.

Użyj functions.config, aby uzyskać dostęp do konfiguracji środowiska w funkcji

Niektóre konfiguracje są udostępniane automatycznie w zarezerwowanej przestrzeni nazw firebase. Konfiguracja środowiska jest udostępniana w ramach funkcji działającej za pomocą narzędzia functions.config(). Aby użyć powyższej konfiguracji, Twój kod może wyglądać tak:

const functions = require('firebase-functions');
const request = require('request-promise');

exports.userCreated = functions.database.ref('/users/{id}').onWrite(event => {
  let email = event.data.child('email').val();

  return request({
    url: 'https://someservice.com/api/some/call',
    headers: {
      'X-Client-ID': functions.config().someservice.id,
      'Authorization': `Bearer ${functions.config().someservice.key}`
    },
    body: {email: email}
  });
});

Inicjowanie modułu przy użyciu konfiguracji środowiska

Niektóre moduły węzłów są gotowe bez konieczności konfigurowania. Inne moduły wymagają dodatkowej konfiguracji do prawidłowego inicjowania. Zalecamy przechowywanie tej konfiguracji w zmiennych konfiguracji środowiskowych zamiast kodowania na stałe. Dzięki temu kod jest bardziej poręczny, co pozwala na udostępnianie aplikacji na zasadach open source oraz łatwe przełączanie się między wersją produkcyjną a testową.

Na przykład moduł Slack Node SDK może wyglądać tak:

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 środowiska slack.url:

firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX

Dodatkowe polecenia dla środowiska

  • firebase functions:config:unset key1 key2 usuwa określone klucze z konfiguracji
  • firebase functions:config:clone --from <fromProject> sklonuje środowisko innego projektu do obecnie aktywnego projektu.

Zmienne środowiskowe wypełniane automatycznie

Istnieją zmienne środowiskowe, które są automatycznie wypełniane w środowisku wykonawczym funkcji i w funkcjach emulowanych lokalnie. Obejmują one te wypełniane 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 przy zainicjowaniu pakietu Firebase Admin SDK bez użycia argumentów. Jeśli piszesz funkcje w języku JavaScript, zainicjuj je w ten sposób:

const admin = require('firebase-admin');
admin.initializeApp();

Jeśli piszesz funkcje w języku TypeScript, zainicjuj go 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 z użyciem domyślnej konfiguracji projektu przy użyciu danych logowania konta usługi, możesz wczytać dane logowania z pliku i dodać je do usługi 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);