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). 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.

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ść. Z drugiej strony 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 kodzie. Wartości tych parametrów są dostępne zarówno podczas wdrażania funkcji, podczas konfigurowania opcji wdrażania i czasu wykonywania, jak i podczas wykonywania. Oznacza to, że interfejs wiersza poleceń zablokuje wdrożenie chyba że wszystkie parametry mają prawidłową wartość.

Node.js

const { onRequest } = require('firebase-functions/v2/https');
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 = onRequest(
  { minInstances: minInstancesConfig },
(req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

Python

from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")
WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")

# To use configured parameters inside the config for a function, provide them
# directly. To use them at runtime, call .value() on them.
@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    return https_fn.Response(f'{WELCOME_MESSAGE.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 ma ich w tych plikach i nie ma ustawionej zmiennej 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 przed mają wartości rzeczywiste. 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() 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 .

Node.js

const { GoogleGenerativeAI } = require('@google/generative-ai');
const { defineSecret } = require('firebase-functions/params');
const { onInit } = require('firebase-functions/v2/core');

const apiKey = defineSecret('GOOGLE_API_KEY');

let genAI;
onInit(() => {
  genAI = new GoogleGenerativeAI(apiKey.value());
})

Python

from firebase_functions.core import init
from firebase_functions.params import StringParam, PROJECT_ID
import firebase_admin
import vertexai

location = StringParam("LOCATION")

x = "hello"

@init
def initialize():
  # Note: to write back to a global, you'll need to use the "global" keyword
  # to avoid creating a new local with the same name.
  global x
  x = "world"
  firebase_admin.initialize_app()
  vertexai.init(PROJECT_ID.value, location.value)

Jeśli używasz parametrów typu Secret, pamiętaj, że są one dostępne tylko w procesie funkcji, które powiązały obiekt tajny. Jeśli obiekt tajny jest powiązany tylko w niektórych funkcjach sprawdź, czy secret.value() nie jest fałszywy, zanim go użyjesz.

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. 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:

Node.js

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: params.select(["odd", "even"])});

const memory = defineInt("MEMORY", {
  description: "How much memory do you need?",
  input: params.select({ "micro": 256, "chonky": 2048 }),
});

const extensions = defineList("EXTENSIONS", {
  description: "Which file types should be processed?",
  input: params.multiSelect(["jpg", "tiff", "png", "webp"]),
});

const storageBucket = defineString('BUCKET', {
  description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets",
  input: params.PICK_STORAGE_BUCKET,
});

Python

from firebase_functions.params import (
    StringParam,
    ListParam,
    TextInput,
    SelectInput,
    SelectOptions,
    ResourceInput,
    ResourceType,
)

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")

WELCOME_MESSAGE = StringParam(
    "WELCOME_MESSAGE",
    default="Hello World",
    description="The greeting that is returned to the caller of this function",
)

ONLY_PHONE_NUMBERS = StringParam(
    "PHONE_NUMBER",
    input=TextInput(
        validation_regex="\d{3}-\d{3}-\d{4}",
        validation_error_message="Please enter a phone number in the format XXX-YYY-XXX",
    ),
)

SELECT_OPTION = StringParam(
    "PARITY",
    input=SelectInput([SelectOptions(value="odd"), SelectOptions(value="even")]),
)

STORAGE_BUCKET = StringParam(
    "BUCKET",
    input=ResourceInput(type=ResourceType.STORAGE_BUCKET),
    description="This will automatically populate the selector field with the deploying Cloud Project's storage buckets",
)

Typy parametrów

Konfiguracja z parametrami zapewnia silne typowanie wartości parametrów i obsługuje również 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
  • Lista (Node.js)

Wartości parametrów i wyrażenia

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 funkcji jako opcję czasu wykonywania, prześlij go bezpośrednio:

Node.js

const { onRequest } = require('firebase-functions/v2/https');
const { defineInt } = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

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

Python

from firebase_functions import https_fn
from firebase_functions.params import IntParam

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")

@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    ...

Poza tym, jeśli musisz porównać z parametrem, aby wiedzieć, co musisz użyć wbudowanych komparatorów zamiast sprawdzając wartość:

Node.js

const { onRequest } = require('firebase-functions/v2/https');
const environment = params.defineString(‘ENVIRONMENT’, {default: 'dev'});

// use built-in comparators
const minInstancesConfig = environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = onRequest(
  { minInstances: minInstancesConfig },
  (req, res) => {
    //…

Python

from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam

ENVIRONMENT = StringParam("ENVIRONMENT", default="dev")
MIN_INSTANCES = ENVIRONMENT.equals("PRODUCTION").then(10, 0)

@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    ...

Parametry i wyrażenia parametrów używane tylko w czasie działania mogą być za pomocą funkcji value:

Node.js

const { onRequest } = require('firebase-functions/v2/https');
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 = onRequest(
(req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

Python

from firebase_functions import https_fn
from firebase_functions.params import StringParam

WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")

@https_fn.on_request()
def hello_world(req):
    return https_fn.Response(f'{WELCOME_MESSAGE.value()}! I am a function!')

Wbudowane parametry

Pakiet SDK Cloud Functions oferuje 3 zdefiniowane wstępnie parametry dostępne w podpakiecie firebase-functions/params:

Node.js

  • projectID – projekt Cloud, w którym działa 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 jest włączony w projekcie Firebase).

Python

  • PROJECT_ID – projekt Cloud, w którym działa ta funkcja.
  • DATABASE_URL – adres URL wystąpienia Bazy danych czasu rzeczywistego powiązanego z funkcją (jeśli jest włączone w projekcie Firebase).
  • STORAGE_BUCKET – 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 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 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:

Node.js

const { onRequest } = require('firebase-functions/v2/https');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');

export const postToDiscord = onRequest(
  { secrets: [discordApiKey] },
  (req, res) => {
  const apiKey = discordApiKey.value();
    //…

Python

from firebase_functions import https_fn
from firebase_functions.params import SecretParam

DISCORD_API_KEY = SecretParam('DISCORD_API_KEY')

@https_fn.on_request(secrets=[DISCORD_API_KEY])
def post_to_discord(req):
    api_key = DISCORD_API_KEY.value

Wartości tajnych danych 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 (w projektach opartych na Node.js) lub os.environ (w projektach opartych na Pythonie).

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:

Node.js

// Responds with "Hello Earth and Humans"
exports.hello = onRequest((request, response) => {
  response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});

Python

import os

@https_fn.on_request()
def hello(req):
    return https_fn.Response(
        f"Hello {os.environ.get('PLANET')} and {os.environ.get('AUDIENCE')}"
    )

Wdrażanie wielu zestawów zmiennych środowiskowych

Jeśli potrzebujesz alternatywnego zestawu zmiennych środowiskowych dla projektów Firebase (np. przejściowego i produkcyjnego), utwórz plik .env.<project or alias> i wpisz w nim zmienne środowiskowe dotyczące Twojego projektu. 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.

Na przykład projekt może zawierać te 3 pliki z nieco innymi wartościami na potrzeby wersji deweloperskiej i produkcyjnej:

.env .env.dev .env.prod
PLANET=Ziemia

AUDIENCE=ludzie

AUDIENCE=Dev Humans 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. W plikach .env nie używaj tych kluczy:

  • 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
  • PROJEKT_GCP
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • TYP_FUNKCJI_TRIGGER_TYP
  • 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 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 pliki .env są sprawdzane w kontroli źródłowej.

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 obiektu tajnego i korzystanie z niego

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

Aby utworzyć obiekt tajny i z niego korzystać:

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

    firebase functions:secrets:set SECRET_NAME

  2. Wpisz wartość w polu SECRET_NAME.

    W interfejsie wiersza poleceń wyświetla się komunikat o udanym zakończeniu i ostrzeżenie, że musisz wdrożyć funkcje, aby zmiany zaczęły obowiązywać.

  3. Przed wdrożeniem upewnij się, że kod funkcji zezwala funkcji na dostęp do obiektu tajnego za pomocą parametru runWith:

    Node.js

    const { onRequest } = require('firebase-functions/v2/https');

exports.processPayment = onRequest(
  { secrets: ["SECRET_NAME"] },
  (req, res) => {
    const myBillingService = initializeBillingService(
      // reference the secret value
      process.env.SECRET_NAME
    );
    // Process the payment
  }
);

    Python

    import os
from firebase_functions import https_fn

@https_fn.on_request(secrets=["SECRET_NAME"])
def process_payment(req):
    myBillingService = initialize_billing(key=os.environ.get('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ść:

    Node.js

    exports.anotherEndpoint = 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
});

    Python

    @https_fn.on_request()
def another_endpoint(req):
    return https_fn.Response(f"The secret API key is {os.environ.get("SECRET_NAME")}")
    # Responds with "The secret API key is None" because the `secrets` 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 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. 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 nie odwołuje się do tego obiektu. 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

Dyrektywa Secret Manager zezwala na 6 aktywnych wersji obiektu tajnego bez opłat. Oznacza to, że w Firebase możesz mieć 6 obiektów tajnych miesięcznie projektu z Google Cloud.

Domyślnie narzędzie wiersza poleceń Firebase automatycznie usuwa nieużywane wersje obiektów tajnych, gdy jest to właściwe, np. gdy wdrażasz funkcje z nową wersją obiektu tajnego. Możesz też aktywnie usuwać nieużywane sekrety za pomocą funkcji functions:secrets:destroy i functions:secrets:prune.

Secret Manager umożliwia 10 000 nierozliczonych operacji dostępu miesięcznego w obiektu tajnego. Identyfikatory funkcji odczytują tylko sekrety określone w parametrze runWith za każdym razem, gdy są uruchamiane 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 znajdziesz w Secret ManagerCeny.

Wsparcie dotyczące emulatora

Konfiguracja środowiska z Dotenv jest przeznaczona do współpracy 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 nieco różne wartości w przypadku programowania i testów lokalnych:

.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 środowiskowe w ten sposób:

  $ 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ż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 produkcyjnych obiektów tajnych 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 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 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

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 można przekształcić automatycznie, ponieważ mogą być nieprawidłowe lub zawierać 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 niektóre wartości są poufne i nie powinny zostać ujawnione, usuń je z plików .env i przechowuj bezpiecznie w plikach 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 Zmienne środowiskowe.