Häufig sind für die Funktionen zusätzliche Konfigurationsschritte erforderlich, z. B.: Drittanbieter-API-Schlüssel oder anpassbare Einstellungen verwenden. 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). Dies bietet eine stark typisierte Umgebung Konfiguration mit Parametern, die zum Zeitpunkt der Bereitstellung validiert werden. verhindert Fehler und vereinfacht die Fehlerbehebung.
- Dateibasierte Konfiguration von Umgebungsvariablen Bei diesem Ansatz erstellen Sie manuell ein dotenv-Datei zum Laden 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 Definieren der Konfiguration deklarativ in Ihrer Codebasis. Der Wert dieser Parameter ist sowohl während der Funktionsbereitstellung als auch beim Festlegen der Bereitstellung und der Laufzeit verfügbar. und bei der Ausführung. Das bedeutet, dass die Befehlszeile sofern 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!')
Bei der Bereitstellung einer Funktion mit parametrisierten Konfigurationsvariablen
Firebase CLI versucht zuerst, die 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 mit dem Namen .env.<project_ID>
im Verzeichnis functions/
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 Entwicklungsablauf kann es sinnvoll sein, die generierte .env.<project_ID>
-Datei der Versionskontrolle 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 bedeutet, dass das Abrufen von Parameterwerten im globalen Gültigkeitsbereich 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, 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 diese nur
die das Secret gebunden haben. Wenn ein Secret nur in einigen 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
werden nach Werten gefragt. 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. Folgende Typen werden unterstützt:
- Secret
- String
- Boolesch
- Ganzzahl
- Float
- Liste (Node.js)
Parameterwerte und Ausdrücke
Firebase wertet Ihre Parameter sowohl zum Zeitpunkt der Bereitstellung als auch während der Funktion aus ausgeführt wird. Aufgrund dieser doppelten Umgebungen müssen Sie beim Vergleichen von Parameterwerten und beim Festlegen von Laufzeitoptionen für Ihre Funktionen besonders vorsichtig sein.
Um einen Parameter als Laufzeitoption an Ihre Funktion zu übergeben, ü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 mit einem Parameter vergleichen müssen, müssen Sie integrierte Vergleichsoperatoren verwenden, Überprüfen des Werts:
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 über ihre value
-Funktion 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 (sofern im Firebase-Projekt aktiviert).STORAGE_BUCKET
: der mit der Funktion verknüpfte Cloud Storage-Bucket (sofern 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 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, kann bei der Konfiguration der Funktion nicht verwendet werden.
Umgebungsvariablen
Cloud Functions for Firebase unterstützt das Dateiformat dotenv, um Umgebungsvariablen, die in einer .env
-Datei angegeben sind, in die Anwendungslaufzeit zu laden. Nach der Bereitstellung können die Umgebungsvariablen über den
process.env
(in Node.js-basierten Projekten) oder
os.environ
(in
Python-basierten Projekten).
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:
Erstellen Sie eine
.env
-Datei in Ihremfunctions/
-Verzeichnis:# Directory layout: # my-project/ # firebase.json # functions/ # .env # package.json # index.js
Öffnen Sie die Datei
.env
zur Bearbeitung und fügen Sie die gewünschten Schlüssel hinzu. Beispiel:PLANET=Earth AUDIENCE=Humans
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 sind, 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 Umgebungsvariablen bereitstellen
Wenn Sie einen alternativen Satz von Umgebungsvariablen für Ihr Firebase-Projekt benötigen
wie Staging oder Produktion, erstellen Sie eine
.env.<project or
alias>
-Datei und schreiben Sie Ihren
projektspezifischen Umgebungsvariablen
verwenden können. Die Umgebungsvariablen von
.env
und projektspezifische .env
-Dateien (falls vorhanden)
in allen bereitgestellten Funktionen enthalten sein.
Ein Projekt könnte beispielsweise die folgenden drei Dateien enthalten, die leicht unterschiedliche Werte für Entwicklung und Produktion enthalten:
.env
|
.env.dev
|
.env.prod
|
PLANET=Erde
ZIELGRUPPE=Menschen |
AUDIENCE=Entwicklermenschen | AUDIENCE=Prod Humans |
Angesichts der Werte in diesen separaten Dateien die mit Ihren Funktionen bereitgestellt wurden, hängt vom Zielprojekt ab:
$ 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 in Ihren .env
-Dateien keine der folgenden Schlüssel:
- 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
- EINSTIEGSPUNKT
- GCP_PROJECT
- GCLOUD-PROJEKT
- GOOGLE_CLOUD_PROJECT
- FUNCTION_TRIGGER_TYPE
- FUNCTION_NAME
- FUNKTIONSMEMORY_MB
- FUNKTION_TIMEOUT_SEC
- FUNCTION_IDENTITY
- FUNKTIONSREGION
- 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 sind jedoch keine sichere Möglichkeit, vertrauliche Informationen wie Datenbankanmeldedaten oder API-Schlüssel zu speichern. 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, sodass Sie bei Bedarf einfach von Ihren Funktionen aus darauf zugreifen können.
Secret erstellen und verwenden
Verwenden Sie zum Erstellen eines Secrets die Firebase-Befehlszeile.
So erstellen und verwenden Sie ein Secret:
Führen Sie im Stammverzeichnis Ihres lokalen Projektverzeichnisses den folgenden Befehl aus:
firebase functions:secrets:set SECRET_NAME
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.
Prüfen Sie vor der Bereitstellung, ob der Funktionscode der Funktion den Zugriff auf das Secret mit dem 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 ...
Cloud Functions bereitstellen:
firebase deploy --only functions
Jetzt können Sie wie auf jede andere Umgebungsvariable darauf zugreifen. Wenn dagegen eine andere Funktion, die das Secret in
runWith
versucht, auf das Secret zuzugreifen, und erhält 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.
Sobald die Funktion bereitgestellt ist, hat sie Zugriff auf den Secret-Wert. Nur
für Funktionen, die im runWith
-Parameter ein Secret enthalten,
Zugriff auf das Secret als Umgebungsvariable haben. So können Sie sicherstellen,
dass Secret-Werte nur dort verfügbar sind, wo sie benötigt werden. Dadurch wird das Risiko
versehentlich ein Secret preisgibt.
Secrets verwalten
Verwenden Sie die Firebase-Befehlszeile, um Ihre Secrets zu verwalten. Wenn Sie Secrets auf diese Weise verwalten, Beachten Sie, dass Sie einige Änderungen an der Befehlszeile anpassen und/oder noch einmal bereitstellen müssen verbundenen Funktionen. Zum Beispiel:
- Wenn Sie einen neuen Wert für ein Secret festlegen, müssen Sie alle Funktionen neu bereitstellen, die auf dieses Secret verweisen, damit sie den neuesten Wert abrufen können.
- Wenn Sie ein Secret löschen, achten Sie darauf, dass keine Ihrer bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten geheimen Wert verwenden, schlagen geräuschlos fehl.
Hier eine Zusammenfassung der Firebase-Befehle der Befehlszeile 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 die optionale Version
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 an
CLI-Hilfe ansehen.
So werden Secrets abgerechnet
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 haben können.
Standardmäßig versucht die Firebase CLI, nicht verwendete Secret-Versionen bei Bedarf 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 nur die in ihren runWith
angegebenen Secrets
bei jedem Kaltstart. Wenn Sie viele Funktionsinstanzen haben
viele Geheimnisse gelesen haben, könnte Ihr Projekt diese
Zuschuss überschreiten. Dann kann es passieren,
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. Inhalt von
.env.local
haben Vorrang vor .env
und der projektspezifischen .env
-Datei.
Ein Projekt könnte z. B. diese drei Dateien mit geringfügig unterschiedliche Werte für Entwicklung und lokale Tests:
.env
|
.env.dev
|
.env.local
|
PLANET=Erde
ZIELGRUPPE=Menschen |
AUDIENCE=Dev Humans | AUDIENCE=Menschen vor Ort |
Beim Start im lokalen Kontext lädt der Emulator die Umgebung. Variablen wie hier zu sehen:
$ 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 für Vertrauliche Konfigurationsinformationen speichern und darauf zugreifen. 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 Cloud Functions-Emulatorunterstützung für Umgebungsvariablen können Sie Geheimdatenwerte überschreiben, indem Sie eine .secret.local
-Datei einrichten. So können Sie
Ihre Funktionen einfach lokal zu testen, insbesondere wenn Sie keinen Zugriff
mit dem Secret-Wert.
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 Ihre vorhandenen Umgebungskonfigurationen mit dem Befehl firebase functions:config:export
, um sie zu migrieren:
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, da sie ungültig oder reservierten Schlüssel der Umgebungsvariablen.
Wir empfehlen dir, den Inhalt der generierten .env
-Dateien sorgfältig zu prüfen
bevor Sie die Funktionen bereitstellen oder die .env
-Dateien in der Versionsverwaltung einchecken. Wenn
alle Werte vertraulich sind und nicht offengelegt werden sollten, entfernen Sie sie aus Ihrem .env
und speichern Sie sie 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.