Konfigurowanie środowiska


Często będziesz potrzebować dodatkowej konfiguracji funkcji, np. kluczy API innych firm lub ustawień, które można dostosować. SDK Firebase dla Cloud Functions oferuje wbudowaną konfigurację środowiska, która ułatwia przechowywanie i pobieranie tego typu danych w projekcie.

Do wyboru masz te opcje:

  • Konfiguracja parametryczna (zalecana w większości scenariuszy). Umożliwia to skonfigurowanie środowiska o ściśle określonym typie za pomocą parametrów, które są sprawdzane 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, aby wczytywać zmienne środowiskowe.

W większości przypadków zalecamy konfigurację parametryczną. Dzięki temu podejściu wartości konfiguracji są dostępne zarówno w czasie wykonywania, jak i wdrażania, a wdrażanie jest blokowane, jeśli nie wszystkie parametry mają prawidłową wartość. Natomiast konfiguracja ze zmiennymi środowiskowymi jest niedostępna podczas wdrażania.

Konfiguracja z parametrami

Cloud Functions for Firebase udostępnia interfejs do deklaratywnego definiowania parametrów konfiguracji w kodzie źródłowym. 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 CLI zablokuje wdrożenie, chyba że wszystkie parametry mają prawidłową wartość.

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

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 z parametrami interfejs wiersza poleceń Firebase najpierw próbuje wczytać ich wartości z lokalnych plików .env. Jeśli w tych plikach nie ma tych wartości i nie jest ustawiona zmienna default, podczas wdrażania pojawi się prośba o podanie wartości, które zostaną automatycznie zapisane 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 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 będą miały rzeczywiste wartości. Oznacza to, że pobieranie wartości parametrów w ramach globalnego zakresu powoduje niepowodzenie wdrożenia. W przypadku, gdy chcesz użyć parametru do zainicjowania wartości globalnej, użyj wywołania zwrotnego inicjowania.onInit() Ta funkcja wywoływana jest przed uruchomieniem funkcji w produkcji, ale nie jest wywoływana w czasie wdrażania, więc jest bezpiecznym miejscem do uzyskiwania wartości parametrów.

  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 konfigurować za pomocą obiektu Options, który określa sposób wyświetlania przez CLI promptów z prośbą o wartości. W tym przykładzie ustawiono opcje weryfikacji formatu numeru telefonu, aby zapewnić prostą opcję wyboru i automatyczne wypełnianie opcji wyboru z projektu Firebase:

const { defineString } = require('firebase-functions/params');

const welcomeMessage = defineString('WELCOME_MESSAGE', {default: 'Hello World',
description: 'The greeting that is returned to the caller of this function'});

const onlyPhoneNumbers = defineString('PHONE_NUMBER', {input: {text:
{validationRegex: /\d{3}-\d{3}-\d{4}/, validationErrorMessage: "Please enter
a phone number in the format XXX-YYY-ZZZZ"}}});

const selectedOption = defineString('PARITY', {input: {select: {options:
[{value: "odd"}, {value: "even"}]}}})

const storageBucket = defineString('BUCKET', {input: {resource: {type:
"storage.googleapis.com/Bucket"}}, description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets"})

Typy parametrów

Konfiguracja z parametrami umożliwia szybkie wpisywanie wartości parametrów oraz obsługuje obiekty tajne z usługi Cloud Secret Manager. Obsługiwane typy:

  • Obiekt tajny
  • Ciąg znaków
  • Wartość logiczna
  • Liczba całkowita
  • Liczba zmiennoprzecinkowa

Wartości parametrów i wyrażenia

Firebase ocenia parametry zarówno w momencie wdrożenia, 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 funkcji jako opcję czasu wykonywania, prześlij 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 dodatkowo musisz porównać dane z parametrem, aby wiedzieć, którą opcję wybrać, zamiast sprawdzać wartość, musisz użyć wbudowanych funkcji porównywania:

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) => {
    //…

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/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 zdefiniowane wstępnie parametry, dostępne w podpakiecie firebase-functions/params:

  • projectID – projekt Cloud, w którym działa funkcja.
  • databaseURL – adres URL wystąpienia Bazy danych czasu rzeczywistego powiązanego z funkcją (jeśli jest włączone w projekcie Firebase).
  • storageBucket – zasobnik Cloud Storage powiązany z funkcją (jeśli jest włączony w projekcie Firebase).

Te parametry działają jak zdefiniowane przez użytkownika parametry łańcucha znaków pod każdym względem, z tą różnicą, że ich wartości są zawsze znane interfejsowi wiersza Firebase CLI, więc nie trzeba ich podawać podczas wdrażania ani zapisywać w plikach .env.

Parametry obiektu tajnego

Parametry typu Secret zdefiniowane za pomocą defineSecret() to parametry ciągu znaków, których wartość jest przechowywana w usłudze Cloud Secret Manager. Zamiast sprawdzać lokalny plik .env i zapisywać w nim nową wartość, jeśli jest ona nieobecna, parametry obiektów tajnych sprawdzają ich istnienie w usłudze Cloud Secret Manager i proszą o interaktywną wartość nowego obiektu tajnego podczas wdrażania.

Zdefiniowane w ten sposób parametry tajne 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 format pliku dotenv do wczytywania zmiennych środowiskowych określonych w pliku .env w środowisku wykonawczym 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 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 zestawów zmiennych środowiskowych

Jeśli potrzebujesz alternatywnego zestawu zmiennych środowiskowych dla swoich projektów Firebase (np. środowiska przejściowego i produkcyjnego), utwórz plik .env.<project or alias> i wpisz w nim zmienne środowiskowe związane z danym projektem. Zmienne środowiskowe z plików .env i plików .env (jeśli istnieją) związanych z poszczególnymi projektami zostaną uwzględnione we wszystkich 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=Dev Humans AUDIENCE=Prod Humans

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ą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
  • 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_CONFIGURATION

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

Zmienne środowiskowe przechowywane w plikach .env można używać do konfigurowania funkcji, ale nie są one bezpiecznym sposobem przechowywania poufnych informacji, 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 konfiguracyjnych, usługa Cloud Functions for Firebase integruje się z usługą Google Cloud Secret Manager. Ta zaszyfrowana usługa przechowuje wartości konfiguracji w bezpieczny sposób, a jednocześnie umożliwia łatwy dostęp z funkcji w razie potrzeby.

Tworzenie obiektu tajnego i korzystanie z niego

Aby utworzyć obiekt tajny, użyj interfejsu wiersza poleceń Firebase.

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

  1. W katalogu głównym katalogu 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 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 niego dostęp tak jak do każdej innej zmiennej środowiskowej. 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 tam, gdzie są potrzebne, co zmniejsza ryzyko przypadkowego ujawnienia obiektu tajnego.

Zarządzanie obiektami tajnymi

Aby zarządzać obiektami tajnymi, użyj interfejsu wiersza poleceń Firebase. Podczas zarządzania obiektami tajnymi w ten sposób pamiętaj, że niektóre zmiany w CLI wymagają modyfikacji lub ponownego wdrożenia powiązanych funkcji. W szczególności:

  • 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, które używają usuniętych wartości tajnych, nie będą działać.

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ć opcjonalny parametr version, aby zarządzać 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ą rozliczane obiekty tajne

Secret Manager umożliwia bezpłatnie korzystanie z 6 aktywnych wersji obiektów tajnych. Oznacza to, że w projekcie Firebase możesz mieć 6 obiektów tajnych miesięcznie bez ponoszenia opłat.

Domyślnie narzędzie wiersza poleceń Firebase automatycznie usuwa nieużywane wersje obiektów tajnych, gdy jest to właściwe, 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.

Secret Manager umożliwia 10 000 nierozliczonych miesięcznych operacji dostępu do obiektu tajnego. Identyfikatory funkcji odczytują tylko tajne informacje określone w parametrze runWith za każdym razem, gdy są uruchamiane na zimno. Jeśli masz wiele wystąpień funkcji, które odczytują wiele tajemnic, Twój projekt może przekroczyć ten limit. W takim przypadku zostanie naliczona opłata w wysokości 0,03 USD za 10 tys. operacji dostępu.

Więcej informacji znajdziesz w Secret ManagerCeny.

Wsparcie dotyczące emulatora

Konfiguracja środowiska za pomocą dotenv jest przeznaczona do interakcji z lokalnym Cloud Functions emulatorem.

Jeśli używasz lokalnego emulatora Cloud Functions, możesz zastąpić zmienne środowiskowe w projekcie, konfigurując plik .env.local. Treści pliku .env.local mają pierwszeństwo przed plikiem .env i plikiem .env dotyczącym projektu.

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

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

AUDIENCE=Ludzie

AUDIENCE=Programiści AUDIENCE=Local Humans

Gdy zostanie uruchomiony w kontekście lokalnym, emulator wczytuje zmienne środowiska w ten sposób:

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

Tajne informacje i dane logowania w emulatorze Cloud Functions

Emulator Cloud Functions obsługuje używanie obiektów tajnych do przechowywania informacji konfiguracyjnych o charakterze poufnym i dostępu do nich. Domyślnie emulator będzie próbować uzyskać dostęp do tajnych danych produkcyjnych za pomocą domyślnych danych logowania aplikacji. W niektórych sytuacjach, np. w środowiskach CI, emulowany system może nie mieć dostępu do wartości tajnych ze względu na ograniczenia uprawnień.

Podobnie jak w przypadku obsługi zmiennych środowiskowych przez emulator Cloud Functions, możesz zastąpić wartości sekretów, konfigurując plik .secret.local. Dzięki temu możesz łatwo testować funkcje lokalnie, zwłaszcza jeśli nie masz dostępu do wartości obiektu tajnego.

Migracja z konfiguracji środowiska

Jeśli używasz konfiguracji środowiska z functions.config, możesz przenieść istniejącą konfigurację jako zmienne środowiskowe (w formacie dotenv). Interfejs wiersza poleceń Firebase udostępnia polecenie eksportowania, które generuje konfigurację każdego aliasu lub projektu wymienionego w pliku .firebaserc katalogu (w przykładzie poniżej: local, dev i prod) w plikach .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

W niektórych przypadkach pojawi się prośba o wpisanie prefiksu, aby zmienić nazwę wyeksportowanych kluczy zmiennych środowiskowych. Dzieje się tak, ponieważ nie wszystkie konfiguracje można przekształcić automatycznie, ponieważ mogą być nieprawidłowe lub zawierać zarezerwowany klucz zmiennej środowiskowej.

Zalecamy dokładne sprawdzenie treści wygenerowanych plików .env, zanim wdrożysz funkcje lub wdrożysz pliki .env w systemie kontroli wersji. Jeśli niektóre wartości są poufne i nie powinny zostać ujawnione, usuń je z plików .env i przechowuj bezpiecznie w plikach Secret Manager.

Musisz też zaktualizować kod funkcji. Wszystkie funkcje, które używają funkcji functions.config, muszą teraz używać funkcji process.env, jak pokazano w artykule Przechodzenie na drugą generację.

Konfiguracja środowiska

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 na przykład zapisać identyfikator klienta i klucz interfejsu API dla usługi „Some Service”, możesz użyć tego polecenia:

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

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

Ta funkcja opiera się na interfejsie Google Cloud Runtime Configuration API.

Korzystanie z funkcji functions.config do uzyskiwania dostępu 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ć tej 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}
  });
});

Inicjalizacja modułu za pomocą konfiguracji środowiska

Niektóre moduły węzła są gotowe do użycia bez konfiguracji. Inne moduły wymagają dodatkowej konfiguracji, aby można je było prawidłowo zainicjować. 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 wersjami produkcyjnymi i testowymi.

Aby na przykład użyć modułu Slack Node SDK, kod powinien 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 dotyczące środowiska

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

Zmienne środowiskowe wypełniane automatycznie

Istnieją zmienne środowiskowe, które są automatycznie wypełniane w czasie wykonywania funkcji i w emulowanych lokalnie funkcjach. Obejmują one zmienną środowiskową wypełnianą przez Google Cloud, a także zmienną środowiskową charakterystyczną dla 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, gdy inicjujesz pakiet SDK Firebase Admin bez 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 funkcje są pisane 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 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);