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 sich diese Art von Daten für Ihr Projekt ganz einfach speichern und abrufen lassen.

Sie haben folgende Möglichkeiten:

  • Parametriserte Konfiguration (für die meisten Szenarien empfohlen). So erhalten Sie eine stark typisierte Umgebungskonfiguration mit Parametern, die zum Zeitpunkt der Bereitstellung validiert werden. Das verhindert Fehler und vereinfacht die Fehlerbehebung.
  • Dateibasierte Konfiguration von Umgebungsvariablen Bei diesem Ansatz erstellen Sie manuell eine dotenv-Datei zum Laden von Umgebungsvariablen.

Für die meisten Anwendungsfälle wird eine parametrisierte Konfiguration empfohlen. Bei diesem Ansatz sind Konfigurationswerte sowohl zur Laufzeit als auch zum Zeitpunkt der Bereitstellung verfügbar. Die Bereitstellung wird blockiert, es sei denn, alle Parameter haben einen gültigen Wert. Umgekehrt ist die Konfiguration mit Umgebungsvariablen beim Bereitstellen 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, beim Festlegen von Bereitstellungs- und Laufzeitoptionen als auch während der Ausführung verfügbar. Das bedeutet, dass die Befehlszeile das Deployment blockiert, es sei denn, alle Parameter haben einen gültigen Wert.

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 Firebase CLI zuerst, deren Werte aus lokalen Umgebungsdateien zu laden. Wenn sie nicht in diesen Dateien vorhanden sind und keine default festgelegt ist, werden Sie während der Bereitstellung von der Befehlszeile aufgefordert, die Werte anzugeben. Diese werden dann automatisch in einer .env-Datei namens .env.<project_ID> im 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

Abhängig von Ihrem Entwicklungsworkflow kann es sinnvoll sein, die generierte .env.<project_ID>-Datei zur Versionsverwaltung hinzuzufügen.

Parameter im globalen Gültigkeitsbereich verwenden

Während der Bereitstellung wird der Code Ihrer Funktion geladen und geprüft, bevor Ihre Parameter tatsächliche Werte haben. Das Abrufen von Parameterwerten im globalen Gültigkeitsbereich führt also zu einem Bereitstellungsfehler. 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, aber nicht während der Bereitstellung. Daher ist es 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 sie nur in den Prozessen von Funktionen verfügbar, an die das Secret gebunden ist. Wenn ein Secret nur in bestimmten Funktionen gebunden ist, prüfen Sie, ob secret.value() falsch ist, bevor Sie es verwenden.

Verhalten der Befehlszeile konfigurieren

Parameter können mit einem Options-Objekt konfiguriert werden, das steuert, wie die Befehlszeile 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 auszufüllen:

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 strenge Typisierung für Parameterwerte und unterstützt auch Secrets aus Cloud Secret Manager. Unterstützte Typen sind:

  • 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 Dual-Umgebungen ist beim Vergleichen von Parameterwerten und beim Festlegen von Laufzeitoptionen für Funktionen besondere Vorsicht geboten.

Wenn Sie einen Parameter als Laufzeitoption an die 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 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 während der Laufzeit verwendet werden, kann über die 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 mit der Funktion verknüpft ist (sofern im Firebase-Projekt aktiviert).
  • storageBucket: Der Cloud Storage-Bucket, der der Funktion zugewiesen ist (sofern 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 mit der Funktion verknüpft ist (falls im Firebase-Projekt aktiviert).
  • STORAGE_BUCKET: Der mit der Funktion verknüpfte Cloud Storage-Bucket (falls im Firebase-Projekt aktiviert).

Sie funktionieren in jeder Hinsicht wie benutzerdefinierte Stringparameter, mit der Ausnahme, dass ihre Werte der Firebase-Befehlszeile immer bekannt sind und daher bei der Bereitstellung nicht abgefragt und nicht in .env-Dateien gespeichert werden.

Secret-Parameter

Parameter vom Typ Secret, die mit defineSecret() definiert sind, sind Stringparameter, deren Wert in Cloud Secret Manager gespeichert ist. Anstatt sie mit einer lokalen .env-Datei zu vergleichen und bei Bedarf einen neuen Wert in die Datei zu schreiben, wird bei Secret-Parametern geprüft, ob sie in Cloud Secret Manager vorhanden sind. Während der Bereitstellung wird dann interaktiv nach dem Wert eines neuen Secrets gefragt.

Auf diese Weise definierte Secret-Parameter müssen an einzelne Funktionen gebunden sein, die Zugriff darauf haben sollten:

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 Geheimnissen bis zur Ausführung der Funktion ausgeblendet sind, können Sie sie nicht bei der Konfiguration der Funktion verwenden.

Umgebungsvariablen

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

Wenn Sie Ihre Umgebung so konfigurieren möchten, erstellen Sie eine .env-Datei in Ihrem Projekt, fügen Sie die gewünschten Variablen hinzu und führen Sie den Deployment aus:

  1. Erstellen Sie im Verzeichnis functions/ eine Datei .env:

    # 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. Funktionen bereitstellen und prüfen, ob Umgebungsvariablen geladen wurden:

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

Nachdem die benutzerdefinierten Umgebungsvariablen bereitgestellt wurden, kann der 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 Umgebungsvariablen bereitstellen

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

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

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

AUDIENCE=Mensch

AUDIENCE=Dev Humans AUDIENCE=Prod Humans

Je nach den Werten in diesen separaten Dateien variiert die Anzahl der mit Ihren Funktionen bereitgestellten Umgebungsvariablen 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 ab EXT_
  • Alle Schlüssel, die mit FIREBASE_ beginnen
  • Beliebiger Schlüssel aus der folgenden Liste:
  • CLOUD_RUNTIME_CONFIG
  • ENTRY_POINT
  • GCP_PROJECT
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • FUNCTION_TRIGGER_TYPE
  • FUNKTIONSNAME
  • FUNCTION_MEMORY_MB
  • FUNCTION_TIMEOUT_SEC
  • FUNCTION_IDENTITY
  • FUNCTION_REGION
  • FUNCTION_TARGET
  • FUNKTIONSSIGNATURE_TYPE
  • K_SERVICE
  • K_REVISION
  • Port
  • K_CONFIGURATION

Vertrauliche Konfigurationsinformationen speichern und darauf zugreifen

In .env-Dateien gespeicherte Umgebungsvariablen können für die Funktionskonfiguration verwendet werden. Sie sollten jedoch nicht als sichere Methode zum Speichern vertraulicher Informationen wie Datenbankanmeldedaten oder API-Schlüssel betrachtet werden. Das ist besonders wichtig, wenn Sie Ihre .env-Dateien in der Versionsverwaltung überprüfen.

Cloud Functions for Firebase kann mit Google CloudSecret Manager verbunden werden, um vertrauliche Konfigurationsinformationen zu speichern. Dieser verschlüsselte Dienst speichert Konfigurationswerte sicher und ermöglicht gleichzeitig bei Bedarf einfachen Zugriff von Ihren Funktionen.

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.

    In der Befehlszeile wird eine Erfolgsmeldung angezeigt und Sie werden darauf hingewiesen, dass Sie Funktionen bereitstellen müssen, damit die Änderung wirksam wird.

  3. Achten Sie vor der Bereitstellung darauf, dass der Code der Funktion den Zugriff auf das Secret über den Parameter runWith zulässt:

    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 bei jeder anderen Umgebungsvariablen darauf zugreifen. Wenn dagegen eine andere Funktion, die das Secret nicht in runWith angibt, versucht, auf das Secret zuzugreifen, wird ein nicht definierter Wert zurückgegeben:

    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.

Sobald die Funktion bereitgestellt ist, hat sie Zugriff auf den Secret-Wert. Nur Funktionen, die im runWith-Parameter ein Secret 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, und das Risiko eines versehentlichen Datenlecks reduzieren.

Secrets verwalten

Verwalten Sie Ihre Secrets mit der Firebase CLI. Beachten Sie beim Verwalten von Geheimnissen auf diese Weise, dass Sie bei einigen Befehlszeilenänderungen die zugehörigen Funktionen ändern und/oder neu bereitstellen müssen. 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 abrufen können.
  • Achten Sie beim Löschen eines Secrets darauf, dass keine der bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten geheimen Wert verwenden, schlagen geräuschlos fehl.

Im Folgenden finden Sie eine Zusammenfassung der Firebase-Befehlszeilenbefehle 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 Versionsparameter angeben, um eine bestimmte Version zu verwalten. Beispiel:

functions:secrets:access SECRET_NAME[@VERSION]

Für weitere Informationen zu diesen Vorgängen übergeben Sie -h mit dem Befehl, um die Hilfe zur Befehlszeile aufzurufen.

Abrechnung von Secrets

Mit Secret Manager können Sie kostenlos 6 aktive Secret-Versionen verwenden. Das bedeutet, dass Sie in einem Firebase-Projekt kostenlos sechs Secrets pro Monat 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 in Rechnung gestellte Zugriffe pro Monat auf ein Secret zulässig. Funktionsinstanzen lesen bei jedem Kaltstart nur die im runWith-Parameter angegebenen Geheimnisse. Wenn Sie viele Funktionsinstanzen haben, die viele Secrets lesen, wird Ihr Projekt diese Begrenzung möglicherweise ü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.

Emulator-Unterstützung

Die Umgebungskonfiguration mit dotenv ist für die Interkonnektivität 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 die folgenden drei Dateien mit leicht unterschiedlichen Werten für die Entwicklung und lokale Tests enthalten:

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

AUDIENCE=Mensch

AUDIENCE=Entwicklermenschen AUDIENCE=Local Humans

Wenn der Emulator im lokalen Kontext gestartet wird, lädt er die Umgebungsvariablen wie hier gezeigt:

  $ 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 den Standardanmeldedaten für Anwendungen auf Ihre Produktionssecrets zuzugreifen. In bestimmten Situationen, z. B. in CI-Umgebungen, kann der Emulator aufgrund von Berechtigungseinschränkungen nicht auf geheime Werte zugreifen.

Ähnlich wie bei der Unterstützung des Cloud Functions-Emulators für Umgebungsvariablen können Sie Secrets-Werte ü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 ausgegeben wird, das in der .firebaserc-Datei Ihres Verzeichnisses aufgeführt ist (im Beispiel unten local, dev und prod) als .env-Dateien.

Exportieren Sie für die Migration die 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 die exportierten Umgebungsvariablenschlüssel umzubenennen. Das liegt daran, dass nicht alle Konfigurationen automatisch umgewandelt werden können, da sie ungültig sein oder einen reservierten Umgebungsvariablenschlüssel enthalten können.

Wir empfehlen Ihnen, den Inhalt der generierten .env-Dateien sorgfältig zu prüfen, bevor Sie die Funktionen bereitstellen oder die .env-Dateien in die Versionsverwaltung einchecken. Wenn Werte vertraulich sind und nicht gehackt werden sollen, entfernen Sie sie aus Ihren .env-Dateien und speichern Sie sie stattdessen sicher in Secret Manager.

Außerdem müssen Sie den Code Ihrer Funktionen aktualisieren. Für alle Funktionen, in denen functions.config verwendet wird, muss jetzt stattdessen process.env verwendet werden, wie unter Umgebungsvariablen beschrieben.