Skonfiguruj swoje środowisko

Często trzeba dodatkowej konfiguracji dla swoich funkcji, takich jak klucze API trzecich lub ustawień przestrajalnych. Firebase SDK cloud ofert Funkcje wbudowane w konfiguracji środowiska do ułatwiają przechowywanie i pobieranie tego typu danych dla danego projektu.

Można wybierać pomiędzy konfiguracji plików opartych na zmiennych środowiskowych (zalecane) lub konfiguracji środowiska wykonawczego z Firebase CLI i functions.config . Oba podejścia są opisane w tym przewodniku.

Zmienne środowiska

Funkcje Chmura Firebase wspiera dotenv format pliku dla zmiennych środowiskowych załadunku określonych w .env pliku do wykonywania aplikacji. Po wdrożeniu, zmienne środowiskowe mogą być odczytywane za pośrednictwem process.env interfejsu.

Aby skonfigurować środowisko w ten sposób stworzyć .env plik w projekcie, dodać żądane zmienne i wdrażanie:

  1. Tworzenie .env plik w functions/ katalogu:

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

    PLANET=Earth
    AUDIENCE=Humans
    
  3. Funkcje wdrożeniu i sprawdzenia, że zmienne środowiskowe zostały załadowane:

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

Po swojej niestandardowych zmiennych środowiskowych są wdrażane, kod funkcji można uzyskać do nich dostęp z process.env składnią:

// 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 alternatywny zestaw zmiennych środowiskowych dla projektów Firebase (takich jak inscenizacja vs produkcji), utwórz .env. <project or alias > plik i napisać projekt swoistych zmiennych tam. Zmienne środowiskowe z .env i projekt specyficzne .env plików (jeśli takie istnieją) zostaną włączone do wszystkich wdrożonych funkcji.

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
PLANET = Ziemia

PUBLICZNOŚCI = Humans

PUBLICZNOŚCI = Humans Dev WIDOWNI = Humans Prod

Biorąc pod uwagę wartości w tych oddzielnych plikach, zestaw zmiennych środowiskowych rozmieszczonego ze swoimi funkcjami będzie się różnić w zależności od projektu celowego:

$ 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 klawisze zmiennej środowiskowej są zarezerwowane do użytku wewnętrznego. Nie używać któregokolwiek z tych klawiszy w swoim .env plików:

  • Wszystkie klucze zaczynające się X_GOOGLE_
  • Wszystkie klucze zaczynające EXT_
  • Wszystkie klucze zaczynające się FIREBASE_
  • Dowolny klawisz z poniższej listy:
  • CLOUD_RUNTIME_CONFIG
  • PUNKT WEJŚCIA
  • 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

przechowywanie informacji i dostęp wrażliwy konfiguracja

Zmienne środowiskowe przechowywane w .env plików mogą być wykorzystywane do konfiguracji funkcji, ale nie powinno się rozważyć im bezpieczny sposób przechowywać poufne informacje, takie jak bazy danych uwierzytelniających lub kluczy API. Jest to szczególnie ważne, jeśli sprawdzić .env pliki do kontroli źródła.

Aby pomóc Ci przechowywać poufne informacje o konfiguracji, funkcje Chmura integruje Firebase z Google Cloud Tajnej Managera . Ta konfiguracja zapisuje zaszyfrowane eksploatacyjne wartości bezpiecznie, jednocześnie umożliwiając łatwy dostęp od swoich funkcji w razie potrzeby.

Tworzenie i używanie tajemnicy

Aby utworzyć tajemnicę, użyj Firebase CLI.

Aby tworzyć i wykorzystywać w tajemnicy:

  1. Z katalogu lokalnego katalogu projektu, uruchom następujące polecenie:

    firebase functions:secrets:set SECRET_NAME

  2. Wprowadź wartość dla SECRET_NAME .

    Echa komunikat o powodzeniu i CLI ostrzega, że należy wdrożyć funkcje, aby zmiany odniosły skutek.

  3. Przed wdrożeniem, upewnij się, że kod działa funkcja pozwala na dostęp do tajemnicy pomocą runWith parametr:

    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. Funkcje Deploy Cloud

    firebase deploy --only functions

Teraz będzie można uzyskać do niego dostęp, jak każdy inny zmiennej środowiskowej. I odwrotnie, jeśli kolejna funkcja, która nie określa Sekret runWith próbuje uzyskać dostęp do tajemnicy, otrzymuje nieokreślonej wartości:

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

Gdy funkcja jest wdrożony, będzie miał dostęp do tajnych wartości. Tylko funkcje, które w szczególności obejmują tajemnicę w swoim runWith parametr będzie miał dostęp do tej tajemnicy jako zmienną środowiskową. To pomaga upewnić się, że tajne wartości są dostępne tylko wtedy, gdy są potrzebne, co zmniejsza ryzyko przypadkowego wycieka tajemnicę.

zarządzanie tajemnic

Użyj Firebase CLI do zarządzania swoje tajemnice. Podczas zarządzania tajemnice w ten sposób, należy pamiętać, że niektóre zmiany CLI wymagają modyfikacji i / lub przesunięcie związane funkcje. Konkretnie:

  • Ilekroć ustawić nową wartość dla tajemnicy, należy ponownie wdrożyć wszystkie funkcje, które odsyłającego wynika, że tajne im odebrać ostatnią wartość.
  • Jeśli usuniesz tajemnicy, upewnij się, że żaden z wdrożonych odniesień funkcje, które w tajemnicy. Funkcje, które używają tajnego wartości, który został usunięty zawiedzie cicho.

Oto podsumowanie poleceń Firebase CLI dla tajnego zarządzania:

# 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

Dla access i destroy polecenia można podać opcjonalny parametr wersji do zarządzania konkretną wersję. Na przykład:

functions:secrets:access SECRET_NAME[@VERSION]

Aby uzyskać więcej informacji na temat tych operacji, przechodzą -h z poleceniem, aby zobaczyć CLI pomocy.

Jak tajemnice są rozliczane

Tajny Manager umożliwia 6 aktywnych tajnych wersje za darmo. Oznacza to, że można mieć 6 tajemnice miesięcznie w projekcie Firebase bez żadnych kosztów.

Domyślnie próby Firebase CLI do automatycznego niszczenia niewykorzystanych wersje tajne w stosownych przypadkach, na przykład gdy wdrożyć funkcje z nową wersją tajemnicy. Ponadto, można aktywnie oczyścić nieużywane tajemnice użyciu functions:secrets:destroy i functions:secrets:prune .

Tajny Manager umożliwia 10.000 Unbilled operacji miesięcznie dostępu, na tajemnicy. Instancje funkcyjne czytać tylko sekrety określone w ich runWith parametr każdym czasie zimny ich rozpoczęciem. Jeśli masz dużo wystąpień funkcję odczytu wiele tajemnic, projekt może przekroczyć tej kwoty, przy której będziesz naładowany 0,03 $ za operacje 10000 dostępu.

Aby uzyskać więcej informacji, zobacz Ceny Tajny menedżera .

wsparcie emulator

Konfiguracja środowiska z dotenv jest przeznaczony do współdziałania z lokalnym chmurze Funkcje emulatora .

Przy użyciu lokalnego emulator Funkcje Cloud, można zastąpić zmienne środowiskowe dla danego projektu poprzez utworzenie .env.local pliku. Zawartość .env.local mają pierwszeństwo nad .env i projekt specyficznego .env pliku.

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

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

PUBLICZNOŚCI = Humans

PUBLICZNOŚCI = Humans Dev PUBLICZNOŚCI = local Humans

Kiedy rozpoczęła się w kontekście lokalnym, emulator wczytuje zmienne środowiskowe, jak pokazano na rysunku:

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

Sekrety i poświadczenia w chmurze Funkcje emulatorze

Funkcje Chmura emulatora obsługuje użycie tajemnice przechowywania i dostępu do poufnych informacji konfiguracyjnych . Domyślnie emulator będzie próbował uzyskać dostęp do tajemnic produkcyjnych za pomocą domyślnej aplikacji poświadczeń . W pewnych sytuacjach, takich jak środowiskach CI, emulator może nie dostępu tajnych wartości ze względu na ograniczenia uprawnień.

Podobny do Cloud wsparcia Funkcje emulator zmiennych środowiskowych, można przesłonić wartości tajemnice poprzez utworzenie .secret.local pliku. To sprawia, że łatwo można przetestować swoje funkcje lokalnie, zwłaszcza jeśli nie masz dostępu do tajnego wartości.

Migracja z konfiguracją środowiska

Jeśli zostały przy użyciu konfiguracji środowiska z functions.config można przenieść istniejącą konfigurację jako zmienne środowiskowe (w dotenv formacie). Firebase CLI zapewnia polecenie export że wyjścia konfiguracja każdego aliasu lub projektu wymienionego w katalogu za .firebaserc pliku (w przykładzie poniżej, local , dev i prod ) jako .env plików.

Do migracji, wyeksportować istniejące konfiguracje środowiska przy użyciu firebase functions:config:export polecenie:

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 zauważyć, że w niektórych przypadkach, użytkownik zostanie poproszony o wprowadzenie zmiany nazwy przedrostek eksportowane klucze zmiennym otoczeniu. To dlatego, że nie wszystkie konfiguracje mogą być automatycznie przekształcane, ponieważ mogą one być nieważna lub może być zastrzeżony klucz zmienna .

Zalecamy, aby dokładnie sprawdzić zawartość generowanych .env plików przed wdrożeniem swoje funkcje lub sprawdzić .env pliki do kontroli źródła. Jeśli jakieś wartości są wrażliwe i nie powinny być wyciekły, usunąć je z .env plików i przechowywać je bezpiecznie w Tajnej Menedżer zamiast.

Trzeba także zaktualizować swój kod funkcji. Wszelkie funkcje, że stosowanie functions.config będzie teraz musiał użyć process.env zamiast, jak pokazano w zmiennych środowiska naturalnego .

konfiguracja środowiska

Przed wsparcie zmienna środowiskowa została wydana w firebase-functions v3.18.0 , używając functions.config() był Zalecane podejście do konfiguracji środowiska. Takie podejście jest nadal obsługiwana, ale zalecamy wszystkie nowe projekty używać zmiennych środowiskowych zamiast, ponieważ są one prostsze w obsłudze i poprawy przenośności kodu.

Zestaw konfiguracja środowiska z CLI

Do przechowywania danych środowiskowych, można użyć firebase functions:config:set poleceń w Firebase CLI . Każdy klawisz może być przy użyciu przestrzeni nazw okresów do grupowania pokrewnych konfiguracji. Należy pamiętać, że tylko małe litery są przyjmowane w klawisze; wielkie litery nie są dozwolone.

Na przykład, aby przechowywać identyfikator klienta i klucz API dla „Niektórzy Service”, można uruchomić:

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

Pobrać aktualną konfigurację środowiska

Aby sprawdzić, co się obecnie przechowywane w środowisku config dla swojego projektu, można użyć firebase functions:config:get . Będzie wyjście JSON coś takiego:

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

Funkcjonalność ta jest oparta na API Google Cloud Runtime Configuration .

Użyj functions.config do konfiguracji środowiska dostęp do funkcji

Niektóre konfiguracja jest automatycznie dostarczane pod zastrzeżonym firebase nazw. Konfiguracja środowiska są udostępniane wewnątrz swojej funkcji z systemem za pośrednictwem functions.config() . Aby użyć konfiguracji powyżej, 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 środowiska konfigurację zainicjować moduł

Niektóre moduły Node są gotowe bez jakiejkolwiek konfiguracji. Inne moduły potrzebują dodatkowej konfiguracji zainicjować poprawnie. Zalecamy przechowywanie tej konfiguracji w zmiennych konfiguracyjnych środowiska zamiast go ciężko kodowania. Pomaga to zachować swój kod znacznie bardziej mobilny, który umożliwia otwieranie aplikacji lub źródło łatwo przełączać się pomiędzy produkcją i wersji inscenizacji.

Na przykład, aby użyć Gacz Węzeł SDK modułu, można 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 slack.url zmiennej środowiskowej config:

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

Polecenia dodatkowe Środowisko

  • firebase functions:config:unset key1 key2 Usuwa określony klucze z config
  • firebase functions:config:clone --from <fromProject> klony środowisko innego projektu do aktywnego projektu.

Wypełniane automatycznie zmienne środowiskowe

Są zmienne środowiskowe, które są wypełniane automatycznie w funkcji w czasie rzeczywistym i lokalnie emulowane funkcje. Należą do nich te wypełniane przez Google Cloud , a także Firebase specyficznej zmiennej środowiskowej:

process.env.FIREBASE_CONFIG : Udostępnia następujące informacje Firebase projekt config:

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

Taka konfiguracja jest stosowana automatycznie podczas inicjalizacji Firebase Admin SDK bez argumentów. Jeśli piszesz funkcji w JavaScript, zainicjować tak:

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

Jeśli piszesz funkcji w maszynopisie, zainicjować tak:

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

Jeśli trzeba zainicjować Admin SDK z domyślnej konfiguracji projektu przy użyciu poświadczeń konta usługi można załadować poświadczeń z pliku i dodać je do FIREBASE_CONFIG tak:

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

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