Konfigurowanie środowiska


Często będziesz potrzebować dodatkowej konfiguracji swoich funkcji, takiej jak klucze API innych firm lub konfigurowalne ustawienia. Pakiet Firebase SDK dla Cloud Functions oferuje wbudowaną konfigurację środowiska, która ułatwia przechowywanie i pobieranie tego typu danych dla Twojego projektu.

Możesz wybierać pomiędzy trzema opcjami:

  • Konfiguracja sparametryzowana (zalecana w przypadku większości scenariuszy). Zapewnia to konfigurację środowiska o silnym typie z parametrami, które są sprawdzane w czasie wdrażania, co zapobiega błędom i upraszcza debugowanie.
  • Konfiguracja zmiennych środowiskowych oparta na plikach. Dzięki takiemu podejściu ręcznie tworzysz plik dotenv do ładowania zmiennych środowiskowych.
  • Konfiguracja środowiska wykonawczego za pomocą interfejsu wiersza polecenia Firebase i functions.config (tylko Cloud Functions (1. generacji)).

W większości przypadków zalecana jest konfiguracja sparametryzowana. Dzięki takiemu podejściu wartości konfiguracyjne są dostępne zarówno w czasie wykonywania, jak i podczas wdrażania, a wdrażanie jest blokowane, chyba że wszystkie parametry mają prawidłowe wartości. I odwrotnie, konfiguracja ze zmiennymi środowiskowymi nie jest dostępna w czasie wdrażania.

Konfiguracja parametryczna

Cloud Functions dla Firebase udostępnia interfejs do deklaratywnego definiowania parametrów konfiguracyjnych w bazie kodu. Wartość tych parametrów jest dostępna zarówno podczas wdrażania funkcji, podczas ustawiania opcji wdrażania i czasu wykonywania, jak i podczas wykonywania. Oznacza to, że interfejs CLI zablokuje wdrożenie, jeśli wszystkie parametry nie będą miały prawidłowych wartości.

Aby zdefiniować parametry w kodzie, postępuj zgodnie z następującym modelem:

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 sparametryzowanymi zmiennymi konfiguracyjnymi interfejs CLI Firebase najpierw próbuje załadować ich wartości z lokalnych plików .env. Jeśli nie ma ich w tych plikach i nie ustawiono default , interfejs CLI wyświetli monit o podanie wartości 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 przepływu prac programistycznych przydatne może być dodanie wygenerowanego pliku .env.<project_ID> do kontroli wersji.

Skonfiguruj zachowanie CLI

Parametry można konfigurować za pomocą obiektu Options , który kontroluje sposób, w jaki interfejs CLI będzie pytał o wartości. Poniższy przykład ustawia opcje umożliwiające sprawdzenie formatu numeru telefonu, zapewnienie prostej opcji wyboru i automatyczne wypełnienie 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 sparametryzowana zapewnia silne wpisywanie wartości parametrów, a także obsługuje wpisy tajne z Cloud Secret Manager. Obsługiwane typy to:

  • Sekret
  • Strunowy
  • Wartość logiczna
  • Liczba całkowita
  • Platforma

Wartości parametrów i wyrażenia

Firebase ocenia Twoje parametry zarówno w czasie wdrażania, jak i podczas wykonywania funkcji. Ze względu na te podwójne środowiska należy zachować szczególną ostrożność podczas porównywania wartości parametrów i używania 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');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

Dodatkowo, jeśli chcesz porównać parametr, aby wiedzieć, którą opcję wybrać, zamiast sprawdzać wartość, będziesz musiał użyć wbudowanych komparatorów:

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, które są używane tylko w czasie wykonywania, można uzyskać za pomocą ich 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 Cloud Functions SDK oferuje trzy predefiniowane parametry, dostępne z podpakietu firebase-functions/params :

  • projectID — projekt Cloud, w którym działa funkcja.
  • databaseURL — adres URL instancji Realtime Database 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 podobnie jak parametry ciągu zdefiniowane przez użytkownika, z tą różnicą, że ich wartości są zawsze znane interfejsowi CLI Firebase, więc ich wartości nigdy nie będą wyświetlane podczas wdrażania ani zapisywane w plikach .env .

Tajne parametry

Parametry typu Secret , zdefiniowane przy użyciu defineSecret() , reprezentują parametry łańcuchowe, których wartość jest przechowywana w Cloud Secret Manager. Zamiast sprawdzać lokalny plik .env i zapisywać nową wartość w pliku, jeśli go brakuje, parametry tajnego klucza sprawdzają istnienie w Cloud Secret Manager i interaktywnie pytają o wartość nowego klucza tajnego podczas wdrażania.

Zdefiniowane w ten sposób tajne parametry 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();
    //…

Ponieważ wartości sekretów są ukryte do czasu wykonania funkcji, nie można ich użyć podczas konfigurowania funkcji.

Zmienne środowiska

Cloud Functions dla Firebase obsługuje format pliku dotenv do ładowania zmiennych środowiskowych określonych w pliku .env do środowiska wykonawczego aplikacji. Po wdrożeniu zmienne środowiskowe można odczytać za pośrednictwem interfejsu process.env .

Aby skonfigurować środowisko w ten sposób, utwórz plik .env w swoim projekcie, dodaj żądane zmienne i wdróż:

  1. Utwórz plik .env w swoim katalogufunctions functions/ :

    # Directory layout:
    #   my-project/
    #     firebase.json
    #     functions/
    #       .env
    #       package.json
    #       index.js
    
  2. Otwórz plik .env do edycji i dodaj żądane klucze. Na przykład:

    PLANET=Earth
    AUDIENCE=Humans
    
  3. Wdróż funkcje i sprawdź, czy załadowano zmienne środowiskowe:

    firebase deploy --only functions
    # ...
    # i functions: Loaded environment variables from .env.
    # ...
    

Po wdrożeniu niestandardowych zmiennych środowiskowych kod funkcji może uzyskać do nich dostęp za pomocą 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 swoich projektów Firebase (takich jak staging czy produkcja), utwórz plik .env. <project or alias > i zapisz tam zmienne środowiskowe specyficzne dla projektu. Zmienne środowiskowe z .env i plików .env specyficznych dla projektu (jeśli istnieją) zostaną uwzględnione we wszystkich wdrożonych funkcjach.

Na przykład projekt może zawierać te trzy pliki zawierające nieco różne wartości dla rozwoju i produkcji:

.env .env.dev .env.prod
PLANETA=Ziemia

PUBLICZNOŚĆ=Ludzie

PUBLICZNOŚĆ=Ludzie deweloperzy WIDZENNIA=Prod Ludzie

Biorąc pod uwagę wartości w tych oddzielnych plikach, zestaw zmiennych środowiskowych wdrożonych z Twoimi funkcjami 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ące się od X_GOOGLE_
  • Wszystkie klawisze zaczynające się od EXT_
  • Wszystkie klucze zaczynające się od FIREBASE_
  • Dowolny klucz z poniższej listy:
  • CLOUD_RUNTIME_CONFIG
  • PUNKT WEJŚCIA
  • GCP_PROJEKT
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • FUNCTION_TRIGGER_TYPE
  • NAZWA_FUNKCJI
  • FUNCTION_MEMORY_MB
  • FUNCTION_TIMEOUT_SEC
  • FUNCTION_IDENTITY
  • FUNKCJA_REGION
  • FUNKCJA_TARGET
  • FUNCTION_SIGNATURE_TYPE
  • K_SERWIS
  • K_REVISION
  • PORT
  • K_KONFIGURACJA

Przechowuj i uzyskuj dostęp do poufnych informacji konfiguracyjnych

Zmienne środowiskowe przechowywane w plikach .env mogą służyć do konfiguracji funkcji, ale nie należy ich uważać za bezpieczny sposób przechowywania poufnych informacji, takich jak poświadczenia bazy danych lub klucze API. Jest to szczególnie ważne, jeśli sprawdzasz pliki .env w kontroli źródła.

Aby pomóc Ci przechowywać poufne informacje konfiguracyjne, Cloud Functions dla Firebase integruje się z Google Cloud Secret Manager . Ta zaszyfrowana usługa bezpiecznie przechowuje wartości konfiguracyjne, jednocześnie umożliwiając w razie potrzeby łatwy dostęp do funkcji.

Utwórz i użyj sekretu

Aby utworzyć sekret, użyj interfejsu wiersza polecenia Firebase.

Aby utworzyć klucz tajny i go użyć:

  1. W katalogu głównym lokalnego katalogu projektu uruchom następującą komendę:

    firebase functions:secrets:set SECRET_NAME

  2. Wprowadź wartość SECRET_NAME .

    Interfejs CLI wyświetla komunikat o powodzeniu i ostrzega, że ​​należy wdrożyć funkcje, aby zmiana zaczęła obowiązywać.

  3. Przed wdrożeniem upewnij się, że kod funkcji umożliwia funkcji dostęp do sekretu 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 chmury:

    firebase deploy --only functions

Teraz będziesz mieć do niej dostęp jak do każdej innej zmiennej środowiskowej. I odwrotnie, jeśli inna funkcja, która nie określa sekretu w runWith , spróbuje uzyskać dostęp do sekretu, 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 będzie miała dostęp do tajnej wartości. Tylko funkcje, które wyraźnie zawierają klucz tajny w parametrze runWith , będą miały dostęp do tego sekretu jako zmiennej środowiskowej. Dzięki temu możesz mieć pewność, że tajne wartości będą dostępne tylko tam, gdzie są potrzebne, co zmniejsza ryzyko przypadkowego ujawnienia sekretu.

Zarządzanie tajemnicami

Użyj interfejsu wiersza polecenia Firebase, aby zarządzać swoimi sekretami. Zarządzając sekretami w ten sposób, należy pamiętać, że niektóre zmiany CLI wymagają modyfikacji i/lub ponownego wdrożenia powiązanych funkcji. Konkretnie:

  • Za każdym razem, gdy ustawisz nową wartość klucza tajnego, musisz ponownie wdrożyć wszystkie funkcje odwołujące się do tego klucza tajnego, aby pobrały najnowszą wartość.
  • Jeśli usuniesz sekret, upewnij się, że żadna z wdrożonych funkcji nie odwołuje się do tego sekretu. Funkcje korzystające z usuniętej wartości tajnej przestaną działać w trybie dyskretnym.

Oto podsumowanie poleceń Firebase CLI do zarządzania sekretami:

# 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żna podać opcjonalny parametr wersji, aby zarządzać konkretną wersją. Na przykład:

functions:secrets:access SECRET_NAME[@VERSION]

Aby uzyskać więcej informacji na temat tych operacji, przekaż -h z poleceniem, aby wyświetlić pomoc CLI.

Sposób rozliczania tajemnic

Secret Manager umożliwia bezpłatne korzystanie z 6 aktywnych wersji tajnych. Oznacza to, że możesz mieć 6 sekretów miesięcznie w projekcie Firebase bez żadnych kosztów.

Domyślnie interfejs wiersza polecenia Firebase próbuje automatycznie zniszczyć nieużywane wersje sekretu, jeśli to konieczne, na przykład podczas wdrażania funkcji z nową wersją sekretu. Możesz także aktywnie czyścić nieużywane sekrety za pomocą functions:secrets:destroy functions:secrets:prune .

Menedżer sekretów umożliwia wykonanie 10 000 nierozliczonych miesięcznych operacji dostępu do sekretu. Instancje funkcji odczytują tylko wpisy tajne określone w parametrze runWith przy każdym zimnym uruchomieniu. Jeśli masz wiele instancji funkcji odczytujących wiele sekretów, Twój projekt może przekroczyć ten limit i w tym momencie zostanie naliczona opłata w wysokości 0,03 USD za 10 000 operacji dostępu.

Aby uzyskać więcej informacji, zobacz Cennik programu Secret Manager .

Wsparcie emulatora

Konfiguracja środowiska za pomocą dotenv jest zaprojektowana do współpracy z lokalnym emulatorem Cloud Functions .

Korzystając z lokalnego emulatora Cloud Functions, możesz zastąpić zmienne środowiskowe swojego projektu, konfigurując plik .env.local . Zawartość pliku .env.local ma pierwszeństwo przed .env i plikiem .env specyficznym dla projektu.

Na przykład projekt może zawierać te trzy pliki zawierające nieco inne wartości do celów programowania i testowania lokalnego:

.env .env.dev .env.local
PLANETA=Ziemia

PUBLICZNOŚĆ=Ludzie

PUBLICZNOŚĆ=Ludzie deweloperzy PUBLICZNOŚĆ=Lokalni ludzie

Po uruchomieniu w kontekście lokalnym emulator ładuje zmienne środowiskowe, jak pokazano:

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

Klucze tajne i dane uwierzytelniające w emulatorze Cloud Functions

Emulator Cloud Functions obsługuje używanie kluczy tajnych do przechowywania poufnych informacji konfiguracyjnych i uzyskiwania do nich dostępu . Domyślnie emulator będzie próbował uzyskać dostęp do sekretów produkcyjnych przy użyciu domyślnych poświadczeń aplikacji . W niektórych sytuacjach, takich jak środowiska CI, emulator może nie uzyskać dostępu do tajnych wartości z powodu ograniczeń uprawnień.

Podobnie jak w przypadku obsługi emulatorów Cloud Functions dla zmiennych środowiskowych, możesz zastąpić wartości kluczy tajnych, konfigurując plik .secret.local . Ułatwia to lokalne testowanie funkcji, szczególnie jeśli nie masz dostępu do tajnej wartości.

Migracja z konfiguracji środowiska

Jeśli korzystałeś z konfiguracji środowiska za pomocą functions.config , możesz migrować istniejącą konfigurację jako zmienne środowiskowe (w formacie dotenv ). Interfejs wiersza polecenia Firebase udostępnia polecenie eksportu, które generuje konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc Twojego katalogu (w poniższym przykładzie 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

Należy pamiętać, że w niektórych przypadkach zostaniesz poproszony o wprowadzenie przedrostka w celu zmiany nazwy wyeksportowanych kluczy zmiennych środowiskowych. Dzieje się tak dlatego, że nie wszystkie konfiguracje mogą zostać automatycznie przekształcone, ponieważ mogą być nieprawidłowe lub mogą stanowić zarezerwowany klucz zmiennej środowiskowej .

Zalecamy dokładne przejrzenie zawartości wygenerowanych plików .env przed wdrożeniem funkcji lub sprawdzenie 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 zamiast tego przechowuj je bezpiecznie w Secret Manager .

Będziesz także musiał zaktualizować kod funkcji. Wszelkie funkcje korzystające functions.config będą teraz musiały używać zamiast tego process.env , jak pokazano w temacie Aktualizacja do drugiej generacji .

Konfiguracja środowiska

Zanim obsługa zmiennych środowiskowych została udostępniona w 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 wszystkie nowe projekty zamiast tego korzystały ze zmiennych środowiskowych, ponieważ są one prostsze w użyciu i poprawiają przenośność kodu.

Ustaw konfigurację środowiska za pomocą interfejsu CLI

Aby przechowywać dane środowiska, możesz użyć firebase functions:config:set w interfejsie CLI Firebase . Każdy klucz może mieć przestrzeń nazw przy użyciu kropek w celu zgrupowania powiązanej konfiguracji. Należy pamiętać, że w kluczach akceptowane są tylko małe litery ; wielkie litery nie są dozwolone.

Na przykład, aby zapisać identyfikator klienta i klucz API dla „Jakiejś usługi”, 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 obecnie przechowywane w konfiguracji środowiska Twojego projektu, możesz użyć firebase functions:config:get . Wyśle JSON mniej więcej tak:

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

Ta funkcjonalność opiera się na interfejsie API konfiguracji Google Cloud Runtime .

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

Niektóre konfiguracje są automatycznie udostępniane w zarezerwowanej przestrzeni nazw firebase . Konfiguracja środowiska jest dostępna wewnątrz uruchomionej funkcji za pośrednictwem functions.config() . Aby skorzystać z powyższej konfiguracji, Twój kod może wyglądać następująco:

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

Użyj konfiguracji środowiska, aby zainicjować moduł

Niektóre moduły Node są gotowe bez żadnej konfiguracji. Inne moduły wymagają dodatkowej konfiguracji do prawidłowej inicjalizacji. Zalecamy przechowywanie tej konfiguracji w zmiennych konfiguracyjnych środowiska, a nie na stałe jej kodowanie. Pomaga to zachować znacznie większą przenośność kodu, co pozwala na otwarcie aplikacji lub łatwe przełączanie między wersjami produkcyjnymi i przejściowymi.

Na przykład, aby użyć modułu Slack Node SDK , możesz napisać 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ą konfiguracyjną środowiska slack.url :

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

Dodatkowe polecenia środowiska

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

Automatycznie wypełniane zmienne środowiskowe

Istnieją zmienne środowiskowe, które są automatycznie wypełniane w środowisku wykonawczym funkcji i w funkcjach emulowanych lokalnie. Należą do nich te wypełnione przez Google Cloud , a także zmienną środowiskową specyficzną dla Firebase:

process.env.FIREBASE_CONFIG : Zawiera następujące informacje konfiguracyjne projektu Firebase:

{
  databaseURL: 'https://databaseName.firebaseio.com',
  storageBucket: 'projectId.appspot.com',
  projectId: 'projectId'
}

Ta konfiguracja jest stosowana automatycznie po zainicjowaniu pakietu SDK administratora Firebase bez argumentów. Jeśli piszesz funkcje w JavaScript, zainicjuj w ten sposób:

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

Jeśli piszesz funkcje w TypeScript, zainicjuj w ten sposób:

import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
import 'firebase-functions';
admin.initializeApp();

Jeśli chcesz zainicjować pakiet Admin SDK z domyślną konfiguracją projektu przy użyciu poświadczeń konta usługi, możesz załadować poświadczenia z pliku i dodać je do FIREBASE_CONFIG w następujący sposób:

serviceAccount = require('./serviceAccount.json');

const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);