Konfigurierung Ihrer Umgebung


Häufig ist eine zusätzliche Konfiguration für Ihre Funktionen erforderlich, z. B. API-Schlüssel von Drittanbietern oder anpassbare Einstellungen. Das Firebase SDK für Cloud Functions bietet eine integrierte Umgebungskonfiguration, mit der Sie diese Art von Daten für Ihr Projekt ganz einfach speichern und abrufen können.

Sie haben folgende Optionen zur Auswahl:

  • Parametrisierte Konfiguration (für die meisten Szenarien empfohlen). Dadurch wird eine stark typisierte Umgebungskonfiguration mit Parametern bereitgestellt, die bei der Bereitstellung validiert werden. So werden Fehler vermieden und das Debugging vereinfacht.
  • Dateibasierte Konfiguration von Umgebungsvariablen. Bei diesem Ansatz erstellen Sie manuell eine dotenv-Datei zum Laden von Umgebungsvariablen.

Für die meisten Anwendungsfälle wird die parametrisierte Konfiguration empfohlen. Bei diesem Ansatz sind Konfigurationswerte sowohl zur Laufzeit als auch zur Bereitstellungszeit verfügbar. Die Bereitstellung wird blockiert, wenn nicht alle Parameter einen gültigen Wert haben. Umgekehrt ist die Konfiguration mit Umgebungsvariablen zum Zeitpunkt der Bereitstellung nicht verfügbar.

Parametrisierte Konfiguration

Cloud Functions for Firebase bietet eine Schnittstelle zum deklarativen Definieren von Konfigurationsparametern in Ihrer Codebasis. Der Wert dieser Parameter ist sowohl während der Funktionsbereitstellung, wenn Bereitstellungs- und Laufzeitoptionen festgelegt werden, als auch während der Ausführung verfügbar. Das bedeutet, dass das Deployment über die CLI blockiert wird, sofern nicht alle Parameter einen gültigen Wert haben.

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!')

Wenn Sie eine Funktion mit parametrisierten Konfigurationsvariablen bereitstellen, versucht die Firebase CLI zuerst, ihre Werte aus lokalen .env-Dateien zu laden. Wenn sie in diesen Dateien nicht vorhanden sind und kein default festgelegt ist, werden Sie bei der Bereitstellung von der CLI aufgefordert, die Werte anzugeben. Anschließend werden die Werte automatisch in einer .env-Datei mit dem Namen .env.<project_ID> in Ihrem functions/-Verzeichnis gespeichert:

$ 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

Je nach Entwicklungs-Workflow kann es sinnvoll sein, die generierte Datei .env.<project_ID> der Versionsverwaltung hinzuzufügen.

Parameter im globalen Bereich verwenden

Während der Bereitstellung wird der Code Ihrer Funktionen geladen und geprüft, bevor Ihre Parameter tatsächliche Werte haben. Das bedeutet, dass das Abrufen von Parameterwerten während des globalen Bereichs zu einem Bereitstellungsfehler führt. Wenn Sie einen Parameter verwenden möchten, um einen globalen Wert zu initialisieren, verwenden Sie den Initialisierungs-Callback onInit(). Dieser Callback wird ausgeführt, bevor Funktionen in der Produktion ausgeführt werden. Er wird jedoch nicht während der Bereitstellung aufgerufen. Daher ist er ein sicherer Ort, um auf den Wert eines Parameters zuzugreifen.

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)

Wenn Sie Parameter vom Typ Secret verwenden, sind diese nur im Prozess von Funktionen verfügbar, an die das Secret gebunden wurde. Wenn ein Secret nur in einigen Funktionen gebunden ist, prüfen Sie, ob secret.value() falsch ist, bevor Sie es verwenden.

CLI-Verhalten konfigurieren

Parameter können mit einem Options-Objekt konfiguriert werden, das steuert, wie die CLI nach Werten fragt. Im folgenden Beispiel werden Optionen festgelegt, um das Format einer Telefonnummer zu validieren, eine einfache Auswahloption bereitzustellen und eine Auswahloption automatisch aus dem Firebase-Projekt zu übernehmen:

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",
)

Parametertypen

Die parametrisierte Konfiguration bietet eine starke Typisierung für Parameterwerte und unterstützt auch Secrets aus Cloud Secret Manager. Folgende Typen werden unterstützt:

  • Secret
  • String
  • Boolesch
  • Ganzzahl
  • Float
  • Liste (Node.js)

Parameterwerte und ‑ausdrücke

Firebase wertet Ihre Parameter sowohl bei der Bereitstellung als auch während der Ausführung Ihrer Funktion aus. Aufgrund dieser beiden Umgebungen ist beim Vergleichen von Parameterwerten und beim Festlegen von Laufzeitoptionen für Ihre Funktionen besondere Vorsicht geboten.

Wenn Sie einen Parameter als Laufzeitoption an Ihre Funktion übergeben möchten, übergeben Sie ihn direkt:

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

Wenn Sie außerdem einen Parameter vergleichen müssen, um zu wissen, welche Option Sie auswählen sollen, müssen Sie integrierte Vergleichsoperatoren verwenden, anstatt den Wert zu prüfen:

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

Auf Parameter und Parameterausdrücke, die nur zur Laufzeit verwendet werden, kann mit der Funktion value zugegriffen werden:

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!')

Integrierte Parameter

Das Cloud Functions SDK bietet drei vordefinierte Parameter, die über das Unterpaket firebase-functions/params verfügbar sind:

Node.js

  • projectID – das Cloud-Projekt, in dem die Funktion ausgeführt wird.
  • databaseURL – die URL der Realtime Database-Instanz, die der Funktion zugeordnet ist (falls im Firebase-Projekt aktiviert).
  • storageBucket: Der Cloud Storage-Bucket, der der Funktion zugeordnet ist (falls im Firebase-Projekt aktiviert).

Python

  • PROJECT_ID – das Cloud-Projekt, in dem die Funktion ausgeführt wird.
  • DATABASE_URL – die URL der Realtime Database-Instanz, die der Funktion zugeordnet ist (falls im Firebase-Projekt aktiviert).
  • STORAGE_BUCKET: Der Cloud Storage-Bucket, der der Funktion zugeordnet ist (falls im Firebase-Projekt aktiviert).

Sie funktionieren in jeder Hinsicht wie benutzerdefinierte Stringparameter. Da ihre Werte jedoch immer in der Firebase-Befehlszeile bekannt sind, werden Sie bei der Bereitstellung nie nach ihren Werten gefragt und sie werden auch nicht in .env-Dateien gespeichert.

Secret-Parameter

Parameter vom Typ Secret, die mit defineSecret() definiert werden, stellen Stringparameter dar, deren Wert in Cloud Secret Manager gespeichert ist. Anstatt eine lokale .env-Datei zu prüfen und einen neuen Wert in die Datei zu schreiben, wenn sie fehlt, wird bei Secret-Parametern geprüft, ob sie in Cloud Secret Manager vorhanden sind. Außerdem wird während der Bereitstellung interaktiv nach dem Wert eines neuen Secrets gefragt.

Auf diese Weise definierte Secret-Parameter müssen an einzelne Funktionen gebunden werden, die darauf zugreifen sollen:

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

Da die Werte von Secrets bis zur Ausführung der Funktion verborgen sind, können Sie sie nicht bei der Konfiguration Ihrer Funktion verwenden.

Umgebungsvariablen

Cloud Functions for Firebase unterstützt das dotenv-Dateiformat zum Laden von Umgebungsvariablen, die in einer .env-Datei für die Laufzeit Ihrer Anwendung angegeben sind. Nach der Bereitstellung können die Umgebungsvariablen über die Schnittstelle process.env (in Node.js-basierten Projekten) oder os.environ (in Python-basierten Projekten) gelesen werden.

Wenn Sie Ihre Umgebung auf diese Weise konfigurieren möchten, erstellen Sie eine .env-Datei in Ihrem Projekt, fügen Sie die gewünschten Variablen hinzu und stellen Sie sie bereit:

  1. Erstellen Sie eine .env-Datei in Ihrem functions/-Verzeichnis:

    # Directory layout:
#   my-project/
#     firebase.json
#     functions/
#       .env
#       package.json
#       index.js

  2. Öffnen Sie die Datei .env zur Bearbeitung und fügen Sie die gewünschten Schlüssel hinzu. Beispiel:

    PLANET=Earth
AUDIENCE=Humans

  3. Stellen Sie Funktionen bereit und prüfen Sie, ob Umgebungsvariablen geladen wurden:

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

Sobald Ihre benutzerdefinierten Umgebungsvariablen bereitgestellt wurden, kann Ihr Funktionscode darauf zugreifen:

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')}"
    )

Mehrere Gruppen von Umgebungsvariablen bereitstellen

Wenn Sie für Ihre Firebase-Projekte alternative Umgebungsvariablen benötigen (z. B. für Staging im Vergleich zur Produktion), erstellen Sie eine .env.<project or alias>-Datei und schreiben Sie dort Ihre projektspezifischen Umgebungsvariablen. Die Umgebungsvariablen aus .env und projektspezifischen .env-Dateien (sofern vorhanden) werden in alle bereitgestellten Funktionen aufgenommen.

Ein Projekt könnte beispielsweise diese drei Dateien mit leicht unterschiedlichen Werten für Entwicklung und Produktion enthalten:

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

AUDIENCE=Humans

AUDIENCE=Dev Humans AUDIENCE=Prod Humans

Angesichts der Werte in diesen separaten Dateien variiert die Menge der Umgebungsvariablen, die mit Ihren Funktionen bereitgestellt werden, je nach Zielprojekt:

$ 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

Reservierte Umgebungsvariablen

Einige Umgebungsvariablenschlüssel sind für die interne Verwendung reserviert. Verwenden Sie keinen dieser Schlüssel in Ihren .env-Dateien:

  • Alle Schlüssel, die mit X_GOOGLE_ beginnen
  • Alle Schlüssel, die mit EXT_ beginnen
  • Alle Schlüssel, die mit FIREBASE_ beginnen
  • Einen beliebigen Schlüssel aus der folgenden Liste:
  • 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

Vertrauliche Konfigurationsinformationen speichern und darauf zugreifen

Umgebungsvariablen, die in .env-Dateien gespeichert sind, können zur Funktionskonfiguration verwendet werden. Sie sollten sie jedoch nicht als sichere Methode zum Speichern vertraulicher Informationen wie Datenbankanmeldedaten oder API-Schlüssel betrachten. Das ist besonders wichtig, wenn Sie Ihre .env-Dateien in die Versionsverwaltung einchecken.

Um Ihnen das Speichern vertraulicher Konfigurationsinformationen zu erleichtern, ist Cloud Functions for Firebase in Google Cloud Secret Manager integriert. In diesem verschlüsselten Dienst werden Konfigurationswerte sicher gespeichert. Bei Bedarf können Ihre Funktionen aber trotzdem einfach darauf zugreifen.

Secret erstellen und verwenden

Verwenden Sie die Firebase CLI, um ein Secret zu erstellen.

So erstellen und verwenden Sie ein Secret:

  1. Führen Sie im Stammverzeichnis Ihres lokalen Projektverzeichnisses den folgenden Befehl aus: 

    firebase functions:secrets:set SECRET_NAME

  2. Geben Sie einen Wert für SECRET_NAME ein.

    Die Befehlszeile gibt eine Erfolgsmeldung aus und warnt, dass Sie Funktionen bereitstellen müssen, damit die Änderung wirksam wird.

  3. Prüfen Sie vor der Bereitstellung, ob der Funktionscode den Zugriff auf das Secret über den Parameter runWith ermöglicht:

    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. Cloud Functions bereitstellen:

    firebase deploy --only functions

    Sie können jetzt wie auf jede andere Umgebungsvariable darauf zugreifen. Wenn eine andere Funktion, die das Secret nicht in runWith angibt, auf das Secret zugreifen möchte, erhält sie einen undefinierten Wert:

    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.

Nachdem Ihre Funktion bereitgestellt wurde, hat sie Zugriff auf den Secret-Wert. Nur Funktionen, die ein Secret im Parameter runWith enthalten, haben Zugriff auf dieses Secret als Umgebungsvariable. So können Sie dafür sorgen, dass Secret-Werte nur dort verfügbar sind, wo sie benötigt werden. Das Risiko, dass ein Secret versehentlich preisgegeben wird, wird dadurch verringert.

Secrets verwalten

Verwenden Sie die Firebase CLI, um Ihre Secrets zu verwalten. Beachten Sie, dass bei der Verwaltung von Secrets auf diese Weise einige CLI-Änderungen erfordern, dass Sie zugehörige Funktionen ändern und/oder neu bereitstellen. Zum Beispiel:

  • Wenn Sie einen neuen Wert für ein Secret festlegen, müssen Sie alle Funktionen, die auf dieses Secret verweisen, neu bereitstellen, damit sie den neuesten Wert übernehmen.
  • Wenn Sie ein Secret löschen, achten Sie darauf, dass keine Ihrer bereitgestellten Funktionen darauf verweist. Funktionen, die einen gelöschten geheimen Wert verwenden, schlagen ohne Fehlermeldung fehl.

Hier finden Sie eine Zusammenfassung der Firebase-CLI-Befehle für die Secret-Verwaltung:

# 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

Für die Befehle access und destroy können Sie den optionalen Parameter „version“ angeben, um eine bestimmte Version zu verwalten. Beispiel:

functions:secrets:access SECRET_NAME[@VERSION]

Weitere Informationen zu diesen Vorgängen erhalten Sie, wenn Sie -h mit dem Befehl übergeben, um die CLI-Hilfe aufzurufen.

Abrechnung von Secrets

Mit Secret Manager können Sie 6 aktive Secret-Versionen kostenlos nutzen. Das bedeutet, dass Sie in einem Firebase-Projekt bis zu sechs Secrets pro Monat kostenlos verwenden können.

Standardmäßig versucht die Firebase-Befehlszeile, nicht verwendete Secret-Versionen automatisch zu löschen, z. B. wenn Sie Funktionen mit einer neuen Version des Secrets bereitstellen. Außerdem können Sie nicht verwendete Secrets mit functions:secrets:destroy und functions:secrets:prune aktiv bereinigen.

Mit Secret Manager sind 10.000 nicht abgerechnete monatliche Zugriffe auf ein Secret möglich. Funktionsinstanzen lesen bei jedem Kaltstart nur die im Parameter runWith angegebenen Secrets. Wenn Sie viele Funktionsinstanzen haben, die viele Secrets lesen, kann Ihr Projekt dieses Kontingent überschreiten. In diesem Fall werden Ihnen 0,03 $pro 10.000 Zugriffsvorgänge in Rechnung gestellt.

Weitere Informationen finden Sie unter Preise für Secret Manager.

Emulatorunterstützung

Die Umgebungskonfiguration mit dotenv ist für die Zusammenarbeit mit einem lokalen Cloud Functions-Emulator konzipiert.

Wenn Sie einen lokalen Cloud Functions-Emulator verwenden, können Sie Umgebungsvariablen für Ihr Projekt überschreiben, indem Sie eine .env.local-Datei einrichten. Der Inhalt von .env.local hat Vorrang vor .env und der projektspezifischen .env-Datei.

Ein Projekt könnte beispielsweise diese drei Dateien mit leicht unterschiedlichen Werten für die Entwicklung und lokale Tests enthalten:

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

AUDIENCE=Humans

AUDIENCE=Dev Humans AUDIENCE=Local Humans

Wenn der Emulator im lokalen Kontext gestartet wird, werden die Umgebungsvariablen wie folgt geladen:

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

Secrets und Anmeldedaten im Cloud Functions-Emulator

Der Cloud Functions-Emulator unterstützt die Verwendung von Secrets zum Speichern und Abrufen vertraulicher Konfigurationsinformationen. Standardmäßig versucht der Emulator, mit Standardanmeldedaten für Anwendungen auf Ihre Produktionsgeheimnisse zuzugreifen. In bestimmten Situationen, z. B. in CI-Umgebungen, kann der Emulator aufgrund von Berechtigungseinschränkungen möglicherweise nicht auf geheime Werte zugreifen.

Ähnlich wie bei der Cloud Functions-Emulatorsupport für Umgebungsvariablen können Sie Geheimniswerte überschreiben, indem Sie eine .secret.local-Datei einrichten. So können Sie Ihre Funktionen ganz einfach lokal testen, insbesondere wenn Sie keinen Zugriff auf den geheimen Wert haben.

Von der Umgebungskonfiguration migrieren

Wenn Sie die Umgebungskonfiguration mit functions.config verwendet haben, können Sie Ihre vorhandene Konfiguration als Umgebungsvariablen (im dotenv-Format) migrieren. Die Firebase-Befehlszeile bietet einen Exportbefehl, mit dem die Konfiguration jedes Alias oder Projekts, das in der .firebaserc-Datei Ihres Verzeichnisses aufgeführt ist (im Beispiel unten local, dev und prod), als .env-Dateien ausgegeben wird.

Exportieren Sie zum Migrieren Ihre vorhandenen Umgebungskonfigurationen mit dem Befehl 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

In einigen Fällen werden Sie aufgefordert, ein Präfix einzugeben, um exportierte Umgebungsvariablenschlüssel umzubenennen. Das liegt daran, dass nicht alle Konfigurationen automatisch transformiert werden können, da sie möglicherweise ungültig sind oder einen reservierten Umgebungsvariablenschlüssel enthalten.

Wir empfehlen, die Inhalte der generierten .env-Dateien sorgfältig zu prüfen, bevor Sie Ihre Funktionen bereitstellen oder die .env-Dateien in die Quellcodeverwaltung einchecken. Wenn Werte vertraulich sind und nicht weitergegeben werden sollten, entfernen Sie sie aus den .env-Dateien und speichern Sie sie stattdessen sicher in Secret Manager.

Außerdem müssen Sie den Code Ihrer Funktionen aktualisieren. Alle Funktionen, die functions.config verwenden, müssen jetzt stattdessen process.env verwenden, wie unter Umgebungsvariablen beschrieben.