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 einfach speichern und abrufen können.
Sie können zwischen diesen Optionen wählen:
- Parametrisierte Konfiguration (für die meisten Szenarien empfohlen). Dadurch erhalten Sie eine stark typisierte Umgebungskonfiguration mit Parametern, die bei der Bereitstellung validiert werden. Das verhindert Fehler und vereinfacht das Debugging.
- Dateibasierte Konfiguration von Umgebungsvariablen. Bei diesem Ansatz erstellen Sie manuell eine dotenv-Datei, um Umgebungsvariablen zu laden.
Für die meisten Anwendungsfälle wird eine parametrisierte Konfiguration empfohlen. Bei diesem Ansatz sind die 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 bei der Bereitstellung nicht verfügbar.
Parametrisierte Konfiguration
Cloud Functions for Firebase bietet eine Schnittstelle, über die Sie Konfigurationsparameter deklarativ in Ihrer Codebasis definieren können. 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 die Bereitstellung blockiert, wenn nicht alle Parameter einen gültigen Wert haben.
So definieren Sie Parameter in Ihrem Code:
const functions = require('firebase-functions/v1');
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 = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
(req, res) => {
res.send(`${welcomeMessage.value()}! I am a function.`);
}
);
Wenn Sie eine Funktion mit parametrisierten Konfigurationsvariablen bereitstellen, versucht die Firebase CLI zuerst, die Werte aus lokalen .env-Dateien zu laden. Wenn sie in diesen Dateien nicht vorhanden sind und kein default festgelegt ist, werden Sie von der Befehlszeile während der Bereitstellung zur Eingabe der Werte aufgefordert. Die Werte werden dann 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 Entwicklungsworkflow kann es sinnvoll sein, die generierte .env.<project_ID>-Datei der Versionsverwaltung hinzuzufügen.
Parameter im globalen Bereich verwenden
Während der Bereitstellung wird der Funktionscode geladen und geprüft, bevor die Parameter tatsächliche Werte haben. Das bedeutet, dass das Abrufen von Parameterwerten im globalen Bereich zu einem Bereitstellungsfehler führt. Wenn Sie einen Parameter zum Initialisieren eines globalen Werts verwenden möchten, 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.
const { GoogleGenerativeAI } = require('@google/generative-ai');
const { defineSecret } = require('firebase-functions/params');
const { onInit } = require('firebase-functions/v1');
const apiKey = defineSecret('GOOGLE_API_KEY');
let genAI;
onInit(() => {
genAI = new GoogleGenerativeAI(apiKey.value());
})
CLI-Verhalten 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 zu füllen:
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: {select: {options:
[{value: "odd"}, {value: "even"}]}}})
const storageBucket = defineString('BUCKET', {input: {resource: {type:
"storage.googleapis.com/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
Informationen zu den Funktionen zum Definieren von Parametern finden Sie in der params-Namespace-Referenz.
Parameterwerte und Ausdrücke
Firebase wertet Ihre Parameter sowohl bei der Bereitstellung als auch während der Ausführung der Funktion aus. Aufgrund dieser dualen 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:
const functions = require('firebase-functions/v1');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
(req, res) => {
//…
Wenn Sie außerdem einen Vergleich mit einem Parameter durchführen müssen, um zu wissen, welche Option Sie auswählen müssen, müssen Sie integrierte Komparatoren verwenden, anstatt den Wert zu prüfen:
const functions = require('firebase-functions/v1');
const { defineBool } = require('firebase-functions/params');
const environment = params.defineString(‘ENVIRONMENT’, {default: ‘dev’});
// use built-in comparators
const minInstancesConfig =environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
(req, res) => {
//…
Auf Parameter und Parameterausdrücke, die nur zur Laufzeit verwendet werden, kann mit der Funktion value zugegriffen werden:
const functions = require('firebase-functions/v1');
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 = functions.https.onRequest(
(req, res) => {
res.send(`${welcomeMessage.value()}! I am a function.`);
}
);
Integrierte Parameter
Das Cloud Functions SDK bietet drei vordefinierte Parameter, die im Unterpaket firebase-functions/params verfügbar sind:
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 mit der Funktion verknüpfte Cloud Storage-Bucket (falls im Firebase-Projekt aktiviert).
Diese funktionieren in jeder Hinsicht wie benutzerdefinierte Stringparameter, mit der Ausnahme, dass ihre Werte der Firebase CLI immer bekannt sind. Daher werden ihre Werte bei der Bereitstellung nie abgefragt und 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 er fehlt, prüfen Secret-Parameter, ob sie in Cloud Secret Manager vorhanden sind, und fordern während der Bereitstellung interaktiv den Wert eines neuen Secrets an.
Auf diese Weise definierte Secret-Parameter müssen an einzelne Funktionen gebunden werden, die Zugriff darauf haben sollen:
const functions = require('firebase-functions/v1');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');
export const postToDiscord = functions.runWith({ secrets: [discordApiKey] }).https.onRequest(
(req, res) => {
const apiKey = discordApiKey.value();
//…
Umgebungsvariablen
Cloud Functions for Firebase unterstützt das Dateiformat dotenv zum Laden von Umgebungsvariablen, die in einer .env-Datei angegeben sind, in Ihre Anwendungslaufzeit. Nach der Bereitstellung können die Umgebungsvariablen über die Schnittstelle process.env gelesen werden.
Wenn Sie Ihre Umgebung so konfigurieren möchten, erstellen Sie in Ihrem Projekt eine .env-Datei, fügen Sie die gewünschten Variablen hinzu und stellen Sie sie bereit:
Erstellen Sie eine
.env-Datei in Ihremfunctions/-Verzeichnis:# Directory layout: # my-project/ # firebase.json # functions/ # .env # package.json # index.jsÖffnen Sie die Datei
.envzur Bearbeitung und fügen Sie die gewünschten Schlüssel hinzu. Beispiel:PLANET=Earth AUDIENCE=HumansStellen 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 mit der Syntax process.env darauf zugreifen:
// Responds with "Hello Earth and Humans"
exports.hello = functions.https.onRequest((request, response) => {
response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});
Mehrere Sätze von Umgebungsvariablen bereitstellen
Wenn Sie für Ihre Firebase-Projekte einen alternativen Satz von Umgebungsvariablen benötigen (z. B. Staging im Vergleich zur Produktion), erstellen Sie eine .env.<project or
alias>-Datei und schreiben Sie dort Ihre projektspezifischen Umgebungsvariablen. Die Umgebungsvariablen aus den Dateien .env und den projektspezifischen .env-Dateien (falls vorhanden) werden in alle bereitgestellten Funktionen einbezogen.
Ein Projekt könnte beispielsweise diese drei Dateien mit leicht unterschiedlichen Werten für Entwicklung und Produktion enthalten:
.env
|
.env.dev
|
.env.prod
|
| PLANET=Erde
AUDIENCE=Humans |
AUDIENCE=Dev Humans | AUDIENCE=Prod Humans |
Aufgrund der Werte in diesen separaten Dateien variiert die Gruppe 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
- Beliebiger 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
In .env-Dateien gespeicherte Umgebungsvariablen können für die Funktionskonfiguration verwendet werden. Sie sollten sie jedoch nicht als sichere Methode zum Speichern sensibler Informationen wie Datenbankanmeldedaten oder API-Schlüssel betrachten. Das ist besonders wichtig, wenn Sie Ihre .env-Dateien in die Versionsverwaltung einchecken.
Damit Sie vertrauliche Konfigurationsinformationen speichern können, ist Cloud Functions for Firebase in Google CloudSecret Manager eingebunden. Dieser verschlüsselte Dienst speichert Konfigurationswerte sicher und ermöglicht gleichzeitig bei Bedarf einen einfachen Zugriff über Ihre Funktionen.
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 weist darauf hin, dass Sie Funktionen bereitstellen müssen, damit die Änderung wirksam wird.
Achten Sie vor der Bereitstellung darauf, dass der Funktionscode der Funktion den Zugriff auf das Secret über den Parameter
runWithermöglicht:exports.processPayment = functions // Make the secret available to this function .runWith({ secrets: ["SECRET_NAME"] }) .onCall((data, context) => { const myBillingService = initializeBillingService( // reference the secret value process.env.SECRET_NAME ); // Process the payment });Cloud Functions bereitstellen:
firebase deploy --only functions
Sie können jetzt wie auf jede andere Umgebungsvariable darauf zugreifen.
Wenn umgekehrt eine andere Funktion, die das Secret nicht in runWith angibt, versucht, auf das Secret zuzugreifen, erhält sie einen undefinierten Wert:
exports.anotherEndpoint = functions.https.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
});
Sobald Ihre Funktion bereitgestellt ist, hat sie Zugriff auf den Secret-Wert. Nur Funktionen, die ein Secret explizit 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. Dadurch wird das Risiko verringert, dass ein Secret versehentlich preisgegeben wird.
Secrets verwalten
Verwenden Sie das Firebase-CLI, um Ihre Secrets zu verwalten. Wenn Sie Secrets auf diese Weise verwalten, beachten Sie, dass bei einigen CLI-Änderungen die zugehörigen Funktionen geändert und/oder neu bereitgestellt werden müssen. Zum Beispiel:
- Wenn Sie einen neuen Wert für ein Secret festlegen, müssen Sie alle Funktionen, die auf dieses Secret verweisen, noch einmal bereitstellen, damit sie den neuesten Wert übernehmen.
- Wenn Sie ein Secret löschen, achten Sie darauf, dass keine Ihrer bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten Secret-Wert verwenden, schlagen ohne Rückmeldung fehl.
Hier ist 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]
Weitere Informationen zu diesen Vorgängen erhalten Sie, wenn Sie -h mit dem Befehl übergeben, um die CLI-Hilfe aufzurufen.
Abrechnung von Secrets
Secret Manager ermöglicht 6 aktive Secret-Versionen kostenlos. Das bedeutet, dass Sie in einem Firebase-Projekt 6 Secrets pro Monat kostenlos haben 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.
Secret Manager ermöglicht 10.000 unberechnete monatliche Zugriffe auf ein Secret. Funktionsinstanzen lesen bei jedem Kaltstart nur die Secrets, die in ihrer Option secrets angegeben sind. Wenn Sie viele Funktionsinstanzen haben, die viele Secrets lesen, überschreitet Ihr Projekt möglicherweise dieses Kontingent. 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 Interaktion 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=Erde AUDIENCE=Humans |
AUDIENCE=Dev Humans | AUDIENCE=Local Humans |
Wenn der Emulator im lokalen Kontext gestartet wird, lädt er die Umgebungsvariablen wie dargestellt:
$ 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 Produktions-Secrets zuzugreifen. In bestimmten Situationen, z. B. in CI-Umgebungen, kann der Emulator aufgrund von Berechtigungseinschränkungen möglicherweise nicht auf Secret-Werte zugreifen.
Ähnlich wie bei der Unterstützung von Umgebungsvariablen im Cloud Functions-Emulator können Sie Secret-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 Secret-Wert haben.
Von der Laufzeitkonfiguration migrieren
Die functions.config API wird eingestellt und im März 2027 außer Betrieb genommen.
Nach diesem Datum schlagen Bereitstellungen mit functions.config fehl.
Um Bereitstellungsfehler zu vermeiden, migrieren Sie Ihre Konfiguration mit der Firebase-Befehlszeile zu Cloud Secret Manager. Dies wird dringend empfohlen, da es die effizienteste und sicherste Methode zur Migration Ihrer Konfiguration ist.
Konfiguration mit der Firebase-Befehlszeile exportieren
Verwenden Sie den Befehl
config export, um Ihre vorhandene Umgebungskonfiguration in ein neues Secret in Cloud Secret Manager zu exportieren:$ firebase functions:config:export i This command retrieves your Runtime Config values (accessed via functions.config()) and exports them as a Secret Manager secret. i Fetching your existing functions.config() from your project... ✔ Fetched your existing functions.config(). i Configuration to be exported: ⚠ This may contain sensitive data. Do not share this output. { ... } ✔ What would you like to name the new secret for your configuration? RUNTIME_CONFIG ✔ Created new secret version projects/project/secrets/RUNTIME_CONFIG/versions/1```Funktionscode aktualisieren, um Secrets zu binden
Wenn Sie die im neuen Secret in Cloud Secret Manager gespeicherte Konfiguration verwenden möchten, verwenden Sie die
defineJsonSecretAPI in Ihrer Funktionsquelle. Achten Sie außerdem darauf, dass Secrets an alle Funktionen gebunden sind, die sie benötigen.Vorher
const functions = require("firebase-functions/v1"); exports.myFunction = functions.https.onRequest((req, res) => { const apiKey = functions.config().someapi.key; // ... });Nachher
const { onRequest } = require("firebase-functions/v2/https"); const { defineJsonSecret } = require("firebase-functions/params"); const config = defineJsonSecret("RUNTIME_CONFIG"); exports.myFunction = onRequest( // Bind secret to your function { secrets: [config] }, (req, res) => { // Access secret values via .value() const apiKey = config.value().someapi.key; // ... });Funktionen bereitstellen
Stellen Sie die aktualisierten Funktionen bereit, um die Änderungen zu übernehmen und die Secret-Berechtigungen zu binden.
firebase deploy --only functions:<your-function-name>
Automatisch ausgefüllte Umgebungsvariablen
Es gibt Umgebungsvariablen, die automatisch in der Funktionslaufzeit und in lokal emulierten Funktionen ausgefüllt werden. Dazu gehören die von Google Cloud ausgefüllten Variablen sowie eine Firebase-spezifische Umgebungsvariable:
process.env.FIREBASE_CONFIG: Liefert die folgenden Konfigurationsinformationen für das Firebase-Projekt:
{
databaseURL: 'https://DATABASE_NAME.firebaseio.com',
storageBucket: 'PROJECT_ID.firebasestorage.app ',
projectId: 'PROJECT_ID'
}
Die Werte in Ihrer tatsächlichen Firebase-Konfiguration können je nach den in Ihrem Projekt bereitgestellten Ressourcen variieren.
Diese Konfiguration wird automatisch angewendet, wenn Sie das Firebase Admin SDK ohne Argumente initialisieren. Wenn Sie Funktionen in JavaScript schreiben, initialisieren Sie sie so:
const admin = require('firebase-admin');
admin.initializeApp();
Wenn Sie Funktionen in TypeScript schreiben, initialisieren Sie so:
import * as functions from 'firebase-functions/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
admin.initializeApp();
Wenn Sie das Admin SDK mit der Standardprojektkonfiguration und den Anmeldedaten des Dienstkontos initialisieren müssen, können Sie die Anmeldedaten aus einer Datei laden und so zu FIREBASE_CONFIG hinzufügen:
serviceAccount = require('./serviceAccount.json');
const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);