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ść.

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

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 klucz tajny. Jeśli klucz tajny jest powiązany tylko z niektórymi funkcjami, przed jego użyciem sprawdź, czy wartość secret.value() jest fałszywa.

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:

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 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
  • Lista (Node.js)

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:

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

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

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:

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 predefiniowane parametry dostępne w podpakiecie firebase-functions/params:

Node.js

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

Python

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

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

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

    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

    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ść:

    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 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ń accessdestroy 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:destroyfunctions: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.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. Po grudniu 2025 r. nowe wdrożenia z functions.config będą kończyć się niepowodzeniem.

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, devprod) jako pliki .env.

Aby przeprowadzić migrację, wyeksportuj istniejącą konfigurację ś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 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 używają znaku functions.config, muszą teraz używać znaku process.env, jak pokazano w sekcji Zmienne środowiskowe.