Konfigurowanie środowiska

.


Często konieczne jest dodatkowe konfigurowanie funkcji, takie jak kluczy interfejsu API firmy zewnętrznej i ustawień z możliwością dostosowania. Pakiet SDK Firebase dla Cloud Functions zawiera oferty z wbudowaną konfiguracją środowiska, co ułatwia przechowywanie i pobieranie tych danych odpowiedni typ danych.

Masz do wyboru 3 opcje:

  • Konfiguracja z parametrami (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.
  • 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. 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ść. Natomiast konfiguracja ze zmiennymi środowiskowymi jest niedostępna podczas wdrażania. obecnie się znajdujesz.

Konfiguracja z parametrami

Cloud Functions for Firebase udostępnia interfejs do definiowania konfiguracji deklaratywnie w bazie kodu. Wartością tych parametrów jest dostępne zarówno podczas wdrażania funkcji, jak i podczas konfigurowania wdrożenia i czasu działania 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 tego modelu:

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 występują w tych plikach i nie jest ustawiony żaden element default, interfejs wiersza poleceń poprosi o ich wartości podczas wdrażania, a następnie automatycznie zapisywać je w Plik .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 przed Parametry te mają wartości rzeczywiste. Oznacza to, że podczas pobierania wartości parametrów w trakcie zakres globalny skutkuje niepowodzeniem wdrożenia. Gdy chcesz użyć atrybutu do zainicjowania wartości globalnej, użyj wywołania zwrotnego inicjowania onInit() To wywołanie zwrotne jest uruchamiane przed wszelkimi funkcjami uruchomionymi w środowisku produkcyjnym, ale jest nie może być wywoływana podczas wdrażania, więc można w bezpiecznym miejscu uzyskać dostęp do funkcji .

  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 działania interfejsu wiersza poleceń zwróci się o wartości. Poniższy przykład zawiera opcje pozwalające zweryfikować formatu numeru telefonu, aby zapewnić prostą opcję wyboru. aby automatycznie uzupełnić opcję 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 szybkie wpisywanie wartości parametrów. obsługują też 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 do funkcji jako opcję środowiska wykonawczego, przekaż 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 udostępnia 3 wstępnie zdefiniowane parametry, które są dostępne z podpakiet firebase-functions/params:

  • projectID – projekt Cloud, w którym działa ta funkcja.
  • databaseURL – adres URL powiązanej instancji Bazy danych czasu rzeczywistego za pomocą funkcji (jeśli ta opcja jest włączona w projekcie Firebase).
  • storageBucket – zasobnik Cloud Storage powiązany z funkcją. (jeśli ta opcja jest włączona w projekcie Firebase).

Funkcje te działają jak ciąg zdefiniowany przez użytkownika. pod każdym względem z wyjątkiem tego, że ich wartości są zawsze znane w interfejsie wiersza poleceń Firebase, ich wartości nie będą wyświetlane podczas wdrażania ani zapisano w .env plikach.

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 sprawdzając w odniesieniu do lokalnego pliku .env i zapisując nową wartość do pliku, jeśli brakujące, sprawdzanie parametrów obiektów tajnych pod kątem istnienia w usłudze Cloud Secret Manager; interaktywne wyświetlanie wartości 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 obiektów tajnych są ukryte do czasu 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 odczytywać za pomocą process.env za pomocą prostego interfejsu online.

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ą 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 .env i pliki .env związane z projektem (jeśli istnieją) będą uwzględnione we wszystkich wdrożonych funkcjach.

Projekt może na przykład zawierać te trzy pliki zawierające nieznacznie różne wartości na potrzeby 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ż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. Nie używaj żadnych: te klucze w Twoich 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ą być używane na potrzeby funkcji konfiguracji, ale nie należy traktować ich jako bezpiecznego sposobu przechowywania takie jak dane logowania do bazy danych lub klucze interfejsu API. Jest to szczególnie ważne, jest ważne, jeśli sprawdzasz pliki .env w kontroli źródła.

Aby ułatwić przechowywanie poufnych informacji konfiguracyjnych, Cloud Functions for Firebase integruje się z usługą Google Cloud Secret Manager. Ta zaszyfrowana usługa bezpiecznie przechowuje wartości konfiguracji, ale w razie potrzeby nadal masz ł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ń 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. Wdróż Cloud Functions:

    firebase deploy --only functions

Będzie można z niej korzystać tak samo jak do wszystkich innych zmiennych środowiskowych. Jeśli inna funkcja, która nie określa obiektu tajnego w runWith próbuje uzyskać dostęp do 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 zawierają obiekt tajny w parametrze runWith, będą mają dostęp do tego obiektu tajnego 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

Używaj interfejsu wiersza poleceń Firebase do zarządzania obiektami tajnymi. Zarządzając obiektami tajnymi w ten sposób, pamiętaj, że niektóre zmiany w interfejsie wiersza poleceń wymagają zmodyfikowania lub ponownego wdrożenia powiązane funkcje. 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 odwołuje się do tego obiektu tajnego. 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ą naliczane opłaty za obiekty tajne

Secret Manager zezwala na 6 aktywnych obiektów tajnych wersje bezpłatnie. Oznacza to, że w Firebase możesz mieć 6 obiektów tajnych miesięcznie projektu z Google Cloud.

Domyślnie interfejs wiersza poleceń Firebase próbuje automatycznie zniszczyć nieużywany obiekt tajny w odpowiednich przypadkach, na przykład przy wdrażaniu funkcji w nowej wersji w tajemnicy. Możesz też aktywnie czyścić nieużywane obiekty tajne za pomocą functions:secrets:destroy i functions:secrets:prune.

Secret Manager umożliwia 10 000 nierozliczonych operacji dostępu miesięcznego w obiektu tajnego. Instancje funkcji odczytują tylko obiekty tajne określone w ich runWith przy każdym uruchomieniu „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 z Dotenv została zaprojektowana tak, aby współdziałała z lokalnego emulatora Cloud Functions.

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 nieznacznie różne wartości w przypadku programowania i testów lokalnych:

.env .env.dev .env.local
PLANET=Ziemia

AUDIENCE=ludzie

AUDIENCE=Programiści AUDIENCE=Lokalni ludzie

Jeśli uruchomi się w kontekście lokalnym, emulator wczyta środowisko. zmienne, tak jak poniżej:

  $ 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 użycie obiektów tajnych do przechowywania poufnych informacji konfiguracyjnych 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 wartości obiektów tajnych z powodu ograniczeń dotyczących 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 konfiguracja środowiska była przez Ciebie używana z functions.config, można przenieść istniejącą konfigurację jako zmienne środowiskowe (w dotenv). Interfejs wiersza poleceń Firebase zawiera polecenie eksportu, które generuje konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc Twojego katalogu (w przykładzie poniżej local, dev i prod) jako pliki .env.

Aby przeprowadzić migrację, wyeksportuj istniejące konfiguracje środowiska przy użyciu Polecenie 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 podanie 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 Wszystkie wartości są poufne i nie powinny zostać ujawnione, usuń je z .env i bezpiecznie przechowywać Secret Manager.

Trzeba 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

Przed wprowadzeniem obsługi zmiennych środowiskowych w firebase-functions v3.18.0 zalecamy korzystanie z metody functions.config() w przypadku konfigurację środowiska. Ta metoda jest nadal obsługiwana, ale zalecamy Wszystkie nowe projekty używają zamiast nich zmiennych środowiskowych, ponieważ są łatwiejsze w użyciu i zwiększyć przenośność kodu.

Ustaw konfigurację środowiska za pomocą interfejsu wiersza poleceń

Aby przechowywać dane środowiska, możesz skorzystać z 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 tylko małe litery są akceptowane w kluczach, wielkie 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 konfiguracje są udostępniane automatycznie w ramach zarezerwowanej firebase przestrzeni nazw. 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}
  });
});

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ą dodatkowych w celu poprawnego zainicjowania. Zalecamy zapisanie tej konfiguracji w zmiennych konfiguracji środowiskowych zamiast umieszczać na stałe w kodzie. To pomaga kod jest znacznie bardziej przenośny, co pozwala na udostępnianie lub łatwo przełączać się między wersją produkcyjną a testową.

Na przykład moduł Slack Node SDK może 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 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 czasie działania i w funkcjach emulowanych lokalnie. Obejmują one: zostały wypełnione 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 podczas inicjowania Firebase Pakiet Admin SDK bez argumentów. Jeśli tworzysz funkcje w języku JavaScript, zainicjuj 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/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
admin.initializeApp();

Jeśli chcesz zainicjować pakiet Admin SDK z użyciem domyślnej konfiguracji projektu za pomocą danych logowania do konta usługi możesz wczytać je z pliku, dodaj je do grupy 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);