Konfigurowanie środowiska


Często funkcje wymagają dodatkowej konfiguracji, np. kluczy interfejsu API innych firm lub ustawień, które można dostosowywać. Firebase SDK do Cloud Functions oferuje wbudowaną konfigurację środowiska, która ułatwia przechowywanie i pobieranie tego typu danych na potrzeby projektu.

Możesz wybrać jedną z tych opcji:

  • Konfiguracja sparametryzowana (zalecana w większości przypadków). Zapewnia to silnie typizowaną konfigurację środowiska z parametrami weryfikowanymi w momencie wdrażania, co zapobiega błędom i ułatwia debugowanie.
  • Konfiguracja zmiennych środowiskowych na podstawie plików. W tym przypadku ręcznie tworzysz plik dotenv do wczytywania zmiennych środowiskowych.

W większości przypadków zalecana jest konfiguracja sparametryzowana. Dzięki temu wartości konfiguracyjne są dostępne 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. Z kolei konfiguracja za pomocą zmiennych środowiskowych nie jest dostępna w momencie wdrażania.

Konfiguracja z parametrami

Cloud Functions for Firebase udostępnia interfejs do deklaratywnego definiowania parametrów konfiguracji w bazie kodu. Wartość tych parametrów jest dostępna zarówno podczas wdrażania funkcji, gdy ustawiasz opcje wdrażania i środowiska wykonawczego, jak i podczas wykonywania. Oznacza to, że interfejs CLI zablokuje wdrażanie, chyba że wszystkie parametry będą miały prawidłową wartość.

Aby zdefiniować parametry w kodzie, postępuj zgodnie z tym modelem:

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 sparametryzowanymi zmiennymi konfiguracyjnymi wiersz 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 default, interfejs CLI poprosi o podanie wartości podczas wdrażania, a następnie automatycznie zapisze je 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 tworzenia może być przydatne dodanie wygenerowanego pliku .env.<project_ID> do systemu kontroli wersji.

Używanie parametrów w zakresie globalnym

Podczas wdrażania kod funkcji jest wczytywany i sprawdzany, zanim parametry uzyskają rzeczywiste wartości. Oznacza to, że pobieranie wartości parametrów w zakresie globalnym powoduje niepowodzenie wdrożenia. Jeśli chcesz użyć parametru do zainicjowania wartości globalnej, użyj wywołania zwrotnego inicjowaniaonInit(). Ta funkcja zwrotna jest uruchamiana przed uruchomieniem jakichkolwiek funkcji w środowisku produkcyjnym, ale nie jest wywoływana w czasie wdrażania, więc jest bezpiecznym miejscem do uzyskiwania 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());
  })

Konfigurowanie działania interfejsu wiersza poleceń

Parametry można skonfigurować za pomocą obiektu Options, który określa, jak interfejs CLI będzie wyświetlać prośby o podanie wartości. W tym przykładzie ustawiono opcje weryfikacji formatu numeru telefonu, udostępniania prostej opcji wyboru i automatycznego wypełniania 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 typowanie wartości parametrów, a także 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 w momencie wdrażania, jak i podczas wykonywania funkcji. Ze względu na te dwa środowiska należy zachować szczególną ostrożność podczas porównywania wartości parametrów i 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/v1');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

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

Jeśli chcesz porównać parametr, aby wiedzieć, którą opcję wybrać, musisz użyć wbudowanych komparatorów zamiast sprawdzać 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) => {
    //…

Do parametrów i wyrażeń parametrów, które są używane tylko w czasie działania, można uzyskać dostęp 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 oferuje 3 predefiniowane parametry dostępne w podpakiecie firebase-functions/params:

  • projectID – projekt w 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 zdefiniowane przez użytkownika parametry ciągu znaków, z tym wyjątkiem, że ponieważ ich wartości są zawsze znane interfejsowi Firebase CLI, nigdy nie będą wyświetlane w monicie podczas wdrażania ani zapisywane w plikach .env.

Parametry obiektu tajnego

Parametry typu Secret zdefiniowane za pomocą defineSecret() to parametry tekstowe, których wartość jest przechowywana w usłudze Cloud Secret Manager. Zamiast sprawdzać lokalny plik .env i zapisywać w nim nową wartość, jeśli jej brakuje, parametry tajne sprawdzają, czy obiekt tajny istnieje w usłudze Cloud Secret Manager, i interaktywnie proszą o podanie wartości nowego obiektu tajnego podczas wdrażania.

Parametry tajne 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 kluczy tajnych są ukryte do momentu wykonania funkcji, więc nie możesz ich używać podczas konfigurowania funkcji.

Zmienne środowiskowe

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

Aby skonfigurować środowisko w ten sposób, utwórz w projekcie plik .env, dodaj do niego odpowiednie zmienne i wdroż go:

  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 wybrane 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 zestawów zmiennych środowiskowych

Jeśli potrzebujesz alternatywnego zestawu zmiennych środowiskowych dla projektów Firebase (np. przejściowych i produkcyjnych), utwórz plik .env.<project or alias> i wpisz w nim zmienne środowiskowe specyficzne dla projektu. Zmienne środowiskowe z plików .env i .env (jeśli istnieją) specyficznych dla projektu zostaną uwzględnione we wszystkich wdrożonych funkcjach.

Na przykład projekt może zawierać te 3 pliki z nieco innymi wartościami dla środowisk deweloperskiego i produkcyjnego:

.env .env.dev .env.prod
PLANET=Earth

AUDIENCE=Humans

AUDIENCE=Dev Humans AUDIENCE=Prod Humans

W zależności od projektu docelowego zestaw zmiennych środowiskowych wdrażanych z funkcjami będzie się różnić w zależności od wartości w tych osobnych plikach:

$ 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 klucze zaczynające się od EXT_
  • Wszystkie klucze zaczynające 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

przechowywać poufne informacje o konfiguracji i uzyskiwać do nich dostęp;

Zmienne środowiskowe przechowywane w plikach .env można wykorzystywać 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 pliki .env są przechowywane w systemie kontroli wersji.

Aby ułatwić przechowywanie informacji poufnych o konfiguracji, Cloud Functions for Firebase jest zintegrowana z Google Cloud Secret Manager. Ta zaszyfrowana usługa bezpiecznie przechowuje wartości konfiguracji, a jednocześnie umożliwia łatwy dostęp do nich z funkcji w razie potrzeby.

Tworzenie obiektu tajnego i korzystanie z niego

Aby utworzyć klucz tajny, użyj interfejsu Firebase.

Aby utworzyć obiekt tajny i go używać:

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

    firebase functions:secrets:set SECRET_NAME

  2. Wpisz wartość w polu SECRET_NAME.

    Interfejs wiersza poleceń wyświetli komunikat o sukcesie i ostrzeżenie, że aby zmiana została zastosowana, musisz wdrożyć funkcje.

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

Teraz możesz uzyskać do niej dostęp tak jak do każdej innej zmiennej środowiskowej. Z kolei jeśli inna funkcja, która nie określa obiektu tajnego w runWith, spróbuje uzyskać do niego dostęp, otrzyma nieokreśloną 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 tajnej. Tylko funkcje, które w parametrze runWith zawierają obiekt tajny, będą miały do niego dostęp jako do zmiennej środowiskowej. Dzięki temu wartości tajne są dostępne tylko tam, gdzie są potrzebne, co zmniejsza ryzyko przypadkowego ujawnienia tajnego klucza.

Zarządzanie obiektami tajnymi

Do zarządzania obiektami tajnymi używaj interfejsu wiersza poleceń Firebase. Pamiętaj, że niektóre zmiany w CLI wymagają zmodyfikowania lub ponownego wdrożenia powiązanych funkcji. Więcej szczegółów:

  • Za każdym razem, gdy ustawisz nową wartość obiektu tajnego, musisz ponownie wdrożyć wszystkie funkcje, które się do niego odwołują, aby mogły one pobrać najnowszą wartość.
  • Jeśli usuniesz obiekt tajny, upewnij się, że żadna z wdrożonych funkcji nie odwołuje się do niego. Funkcje, które używają usuniętej wartości tajnej, będą działać bez zgłaszania błędów.

Oto podsumowanie poleceń interfejsu wiersza poleceń Firebase do zarządzania kluczami 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 wersji, aby zarządzać konkretną wersją. Przykład:

functions:secrets:access SECRET_NAME[@VERSION]

Więcej informacji o tych operacjach znajdziesz, przekazując -h z poleceniem, aby wyświetlić pomoc interfejsu wiersza poleceń.

Jak naliczane są opłaty za obiekty tajne

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

Domyślnie interfejs Firebase CLI próbuje automatycznie usuwać nieużywane wersje obiektu tajnego w odpowiednich przypadkach, np. podczas wdrażania funkcji z nową wersją obiektu tajnego. Możesz też aktywnie usuwać nieużywane klucze tajne za pomocą poleceń functions:secrets:destroy i functions:secrets:prune.

Secret Manager umożliwia 10 tys. niezaksięgowanych operacji dostępu miesięcznie do wpisu tajnego. Instancje funkcji odczytują tylko te klucze tajne, które są określone w parametrze runWith, za każdym razem, gdy są uruchamiane na zimno. Jeśli masz wiele instancji funkcji, które odczytują wiele wpisów tajnych, Twój projekt może przekroczyć ten limit. W takim przypadku będziesz obciążany opłatą w wysokości 0,03 USD za 10 tys. operacji dostępu.

Więcej informacji znajdziesz w sekcji Secret Manager Ceny.

Obsługa emulatora

Konfiguracja środowiska za pomocą dotenv jest przeznaczona do współpracy z lokalnym Cloud Functionsemulatorem.

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

Na przykład projekt może zawierać te 3 pliki z nieco innymi wartościami na potrzeby programowania i testowania lokalnego:

.env .env.dev .env.local
PLANET=Earth

AUDIENCE=Humans

AUDIENCE=Dev Humans AUDIENCE=Local Humans

Po uruchomieniu w kontekście lokalnym emulator wczytuje zmienne środowiskowe w ten sposób:

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

Utajnione informacje i dane logowania w emulatorze Cloud Functions

Emulator Cloud Functions obsługuje używanie 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 obiektów tajnych środowiska produkcyjnego za pomocą domyślnych danych logowania aplikacji. W niektórych sytuacjach, np. w środowiskach CI, emulator może nie mieć dostępu do wartości tajnych z powodu ograniczeń uprawnień.

Podobnie jak w przypadku emulatora Cloud Functions, który obsługuje zmienne środowiskowe, możesz zastąpić wartości kluczy tajnych, konfigurując plik .secret.local. Ułatwia to lokalne testowanie funkcji, zwłaszcza jeśli nie masz dostępu do wartości tajnej.

Migracja z konfiguracji środowiska

Jeśli używasz konfiguracji środowiska z functions.config, musisz przenieść dotychczasową konfigurację jako zmienne środowiskowe (w formacie dotenv) przed końcem 2025 roku, kiedy to functions.config zostanie wycofane. Interfejs wiersza poleceń Firebase udostępnia polecenie eksportu, które generuje konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc w katalogu (w przykładzie poniżej są to local, dev i prod) jako pliki .env.

Aby przeprowadzić migrację, wyeksportuj istniejące konfiguracje środowiska za pomocą poleceniafirebase 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, aby zmienić nazwy wyeksportowanych kluczy zmiennych środowiskowych. Nie wszystkie konfiguracje można przekształcić automatycznie, ponieważ mogą być nieprawidłowe lub mogą być zarezerwowanym kluczem zmiennej środowiskowej.

Zalecamy dokładne sprawdzenie zawartości wygenerowanych .env plików.env przed wdrożeniem funkcji lub zaewidencjonowaniem plików w systemie kontroli wersji. Jeśli jakiekolwiek wartości są poufne i nie powinny wyciec, usuń je z plików .env i zamiast tego przechowuj je bezpiecznie w Secret Manager.

Musisz też zaktualizować kod funkcji. Wszystkie funkcje, które korzystają z functions.config, muszą teraz używać process.env, jak pokazano w artykule o przejściu na funkcje 2 generacji.

Konfiguracja środowiska

Ustawianie konfiguracji ś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że mieć przestrzeń nazw z użyciem kropek, aby grupować powiązane konfiguracje. Pamiętaj, że klucze mogą zawierać tylko małe litery. Wielkie litery są niedozwolone.

Aby na przykład zapisać identyfikator klienta i klucz interfejsu API dla „Some Service”, możesz uruchomić to polecenie:

firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"

Pobieranie bieżącej konfiguracji środowiska

Aby sprawdzić, co jest obecnie przechowywane w konfiguracji środowiska projektu, możesz użyć firebase functions:config:get. Dane wyjściowe JSON będą wyglądać mniej więcej tak:

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

Ta funkcja jest oparta na Google Cloudinterfejsie Runtime Configuration API.

Używanie znaku functions.config do uzyskiwania dostępu do konfiguracji środowiska w funkcji

Niektóre konfiguracje są automatycznie udostępniane w zarezerwowanej przestrzeni nazw firebase. Konfiguracja środowiska jest udostępniana w działającej funkcji za pomocą zmiennej 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}
  });
});

Używanie konfiguracji środowiska do inicjowania modułu

Niektóre moduły Node są gotowe do użycia bez konfiguracji. Inne moduły wymagają dodatkowej konfiguracji, aby można było je prawidłowo zainicjować. Zalecamy przechowywanie tej konfiguracji w zmiennych konfiguracji środowiska, a nie w postaci zakodowanej na stałe. Dzięki temu kod jest znacznie bardziej przenośny, co pozwala udostępniać aplikację na zasadach open source lub łatwo przełączać się między wersjami produkcyjną i testową.

Aby na przykład użyć modułu Slack Node SDK, możesz napisać:

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 środowiska

  • firebase functions:config:unset key1 key2 usuwa z konfiguracji określone klucze.
  • firebase functions:config:clone --from <fromProject> klonuje środowisko innego projektu w bieżącym aktywnym projekcie.

Automatycznie wypełniane zmienne środowiskowe

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

process.env.FIREBASE_CONFIG: zawiera te informacje o konfiguracji projektu Firebase:

{
  databaseURL: 'https://DATABASE_NAME.firebaseio.com',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  projectId: 'PROJECT_ID'
}

Pamiętaj, że wartości w rzeczywistej konfiguracji Firebase mogą się różnić w zależności od zasobów udostępnionych w projekcie.

Ta konfiguracja jest stosowana automatycznie, gdy inicjujesz pakiet Firebase Admin SDK bez argumentów. Jeśli piszesz funkcje w JavaScript, zainicjuj je w ten sposób:

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

Jeśli piszesz funkcje w TypeScript, zainicjuj je 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 domyślną konfiguracją projektu za pomocą danych logowania 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);