Oftmals benötigen Sie zusätzliche Konfigurationen für Ihre Funktionen, z. B. API-Schlüssel von Drittanbietern oder anpassbare Einstellungen. Das Firebase SDK für Cloud Functions bietet eine integrierte Umgebungskonfiguration, um das Speichern und Abrufen dieser Art von Daten für Ihr Projekt zu vereinfachen.
Sie können zwischen drei Optionen wählen:
- Parametrisierte Konfiguration (empfohlen für die meisten Szenarien). Dadurch wird eine stark typisierte Umgebungskonfiguration mit Parametern bereitgestellt, die zum Zeitpunkt der Bereitstellung validiert werden, was Fehler verhindert und das Debuggen vereinfacht.
- Dateibasierte Konfiguration von Umgebungsvariablen . Bei diesem Ansatz erstellen Sie manuell eine dotenv- Datei zum Laden von Umgebungsvariablen.
- Konfiguration der Laufzeitumgebung mit der Firebase-CLI und
functions.config
(nur Cloud Functions (1. Generation)).
Für die meisten Anwendungsfälle wird eine parametrisierte Konfiguration empfohlen. Dieser Ansatz stellt Konfigurationswerte sowohl zur Laufzeit als auch zur Bereitstellungszeit zur Verfügung und die Bereitstellung wird blockiert, sofern 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 innerhalb 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 CLI die Bereitstellung blockiert, es sei denn, alle Parameter haben einen gültigen Wert.
Um Parameter in Ihrem Code zu definieren, folgen Sie diesem Modell:
const functions = require('firebase-functions');
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.`);
}
);
Beim Bereitstellen einer Funktion mit parametrisierten Konfigurationsvariablen versucht die Firebase-CLI zunächst, deren Werte aus lokalen .env-Dateien zu laden. Wenn sie in diesen Dateien nicht vorhanden sind und keine default
festgelegt ist, fordert die CLI während der Bereitstellung zur Eingabe der Werte auf und speichert ihre Werte dann automatisch in einer .env
Datei mit dem Namen .env.<project_ID>
in Ihrem Verzeichnis functions/
“:
$ firebase deploy
i functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i functions: Loaded environment variables from .env.projectId
Abhängig von Ihrem Entwicklungsworkflow kann es sinnvoll sein, die generierte .env.<project_ID>
-Datei zur Versionskontrolle hinzuzufügen.
Konfigurieren Sie das CLI-Verhalten
Parameter können mit einem Options
konfiguriert werden, das steuert, wie die CLI zur Eingabe von Werten auffordert. Das folgende Beispiel legt Optionen fest, 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 Geheimnisse von Cloud Secret Manager. Unterstützte Typen sind:
- Geheimnis
- Zeichenfolge
- Boolescher Wert
- Ganze Zahl
- Schweben
Parameterwerte und Ausdrücke
Firebase wertet Ihre Parameter sowohl zum Zeitpunkt der Bereitstellung als auch während der Ausführung Ihrer Funktion aus. Aufgrund dieser dualen Umgebungen muss beim Vergleich von Parameterwerten und bei deren Verwendung zum Festlegen von Laufzeitoptionen für Ihre Funktionen besondere Vorsicht geboten sein.
Um einen Parameter als Laufzeitoption an Ihre Funktion zu übergeben, übergeben Sie ihn direkt:
const functions = require('firebase-functions');
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 Parameter vergleichen müssen, um zu wissen, welche Option Sie auswählen sollen, müssen Sie integrierte Komparatoren verwenden, anstatt den Wert zu überprüfen:
const functions = require('firebase-functions');
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 über ihre value
zugegriffen werden:
const functions = require('firebase-functions');
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.`);
}
);
Eingebaute 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 Echtzeitdatenbank-Instanz, die mit der Funktion verknüpft ist (sofern im Firebase-Projekt aktiviert). -
storageBucket
– der mit der Funktion verknüpfte Cloud Storage-Bucket (sofern im Firebase-Projekt aktiviert).
Diese funktionieren in jeder Hinsicht wie benutzerdefinierte Zeichenfolgenparameter, außer dass ihre Werte, da ihre Werte der Firebase-CLI immer bekannt sind, bei der Bereitstellung niemals abgefragt oder in .env
Dateien gespeichert werden.
Geheime Parameter
Parameter vom Typ Secret
, definiert mit defineSecret()
, stellen Zeichenfolgenparameter dar, deren Wert im Cloud Secret Manager gespeichert ist. Anstatt anhand einer lokalen .env
Datei zu prüfen und bei Fehlen einen neuen Wert in die Datei zu schreiben, prüfen Secret-Parameter im Cloud Secret Manager, ob sie vorhanden sind, und fordern während der Bereitstellung interaktiv zur Eingabe des Werts eines neuen Secrets auf.
Auf diese Weise definierte geheime Parameter müssen an einzelne Funktionen gebunden werden, die Zugriff auf sie haben sollen:
const functions = require('firebase-functions');
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();
//…
Da die Werte von Geheimnissen bis zur Ausführung der Funktion verborgen bleiben, können Sie sie beim Konfigurieren Ihrer Funktion nicht verwenden.
Umgebungsvariablen
Cloud Functions for Firebase unterstützt das Dateiformat „dotenv“ zum Laden von Umgebungsvariablen, die in einer .env
Datei angegeben sind, in die Laufzeit Ihrer Anwendung. Nach der Bereitstellung können die Umgebungsvariablen über die Schnittstelle process.env
gelesen werden.
Um Ihre Umgebung auf diese Weise zu konfigurieren, erstellen Sie eine .env
Datei in Ihrem Projekt, fügen Sie die gewünschten Variablen hinzu und stellen Sie Folgendes bereit:
Erstellen Sie eine
.env
Datei in Ihremfunctions/
-Verzeichnis:# Directory layout: # my-project/ # firebase.json # functions/ # .env # package.json # index.js
Öffnen Sie die
.env
Datei zum Bearbeiten und fügen Sie die gewünschten Schlüssel hinzu. Zum Beispiel:PLANET=Earth AUDIENCE=Humans
Stellen Sie Funktionen bereit und überprü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 process.env
Syntax 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}`);
});
Bereitstellen mehrerer Sätze von Umgebungsvariablen
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 dort Ihre projektspezifischen Umgebungsvariablen. Die Umgebungsvariablen aus .env
und projektspezifischen .env
Dateien (sofern vorhanden) werden in alle bereitgestellten Funktionen einbezogen.
Ein Projekt könnte beispielsweise diese drei Dateien enthalten, die leicht unterschiedliche Werte für Entwicklung und Produktion enthalten:
.env | .env.dev | .env.prod |
PLANET=Erde PUBLIKUM=Menschen | PUBLIKUM=Entwicklermenschen | PUBLIKUM=Prod Humans |
Angesichts der Werte in diesen separaten Dateien variieren die 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 beginnen mit X_GOOGLE_
- Alle Tasten beginnen mit EXT_
- Alle Schlüssel beginnen mit FIREBASE_
- Jeder Schlüssel aus der folgenden Liste:
- CLOUD_RUNTIME_CONFIG
- EINSTIEGSPUNKT
- GCP_PROJECT
- GCLOUD_PROJECT
- GOOGLE_CLOUD_PROJECT
- FUNCTION_TRIGGER_TYPE
- FUNKTIONSNAME
- FUNCTION_MEMORY_MB
- FUNCTION_TIMEOUT_SEC
- FUNCTION_IDENTITY
- FUNKTION_REGION
- FUNCTION_TARGET
- FUNCTION_SIGNATURE_TYPE
- K_SERVICE
- K_REVISION
- HAFEN
- K_KONFIGURATION
Speichern Sie vertrauliche Konfigurationsinformationen und greifen Sie darauf zu
In .env
Dateien gespeicherte Umgebungsvariablen können für die Funktionskonfiguration verwendet werden, Sie sollten sie jedoch nicht als sichere Möglichkeit zum Speichern vertraulicher Informationen wie Datenbankanmeldeinformationen oder API-Schlüssel betrachten. Dies ist besonders wichtig, wenn Sie Ihre .env
Dateien in die Quellcodeverwaltung einchecken.
Um Ihnen beim Speichern sensibler Konfigurationsinformationen zu helfen, lässt sich Cloud Functions for Firebase in Google Cloud Secret Manager integrieren. Dieser verschlüsselte Dienst speichert Konfigurationswerte sicher und ermöglicht dennoch bei Bedarf einen einfachen Zugriff über Ihre Funktionen.
Erstellen und verwenden Sie ein Geheimnis
Um ein Geheimnis zu erstellen, verwenden Sie die Firebase-CLI.
So erstellen und verwenden Sie ein Geheimnis:
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 CLI gibt eine Erfolgsmeldung aus und warnt Sie, dass Sie Funktionen bereitstellen müssen, damit die Änderung wirksam wird.
Stellen Sie vor der Bereitstellung sicher, dass Ihr Funktionscode der Funktion den Zugriff auf das Geheimnis mithilfe des
runWith
Parameters ermö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-Funktionen bereitstellen:
firebase deploy --only functions
Jetzt können Sie wie auf jede andere Umgebungsvariable darauf zugreifen. Wenn umgekehrt eine andere Funktion, die das Geheimnis nicht in runWith
angibt, versucht, auf das Geheimnis 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 geheimen Wert. Nur Funktionen, deren runWith
Parameter ausdrücklich ein Geheimnis enthält, haben Zugriff auf dieses Geheimnis als Umgebungsvariable. Dadurch können Sie sicherstellen, dass geheime Werte nur dort verfügbar sind, wo sie benötigt werden, wodurch das Risiko einer versehentlichen Preisgabe eines Geheimnisses verringert wird.
Geheimnisse verwalten
Verwenden Sie die Firebase-CLI, um Ihre Geheimnisse zu verwalten. Beachten Sie bei der Verwaltung von Geheimnissen auf diese Weise, dass Sie bei einigen CLI-Änderungen zugehörige Funktionen ändern und/oder erneut bereitstellen müssen. Speziell:
- Immer wenn Sie einen neuen Wert für ein Geheimnis festlegen, müssen Sie alle Funktionen, die auf dieses Geheimnis verweisen, erneut bereitstellen, damit sie den neuesten Wert übernehmen.
- Wenn Sie ein Geheimnis löschen, stellen Sie sicher, dass keine Ihrer bereitgestellten Funktionen auf dieses Geheimnis verweist. Funktionen, die einen gelöschten geheimen Wert verwenden, schlagen stillschweigend fehl.
Hier ist eine Zusammenfassung der Firebase-CLI-Befehle für die Geheimnisverwaltung:
# 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 access
und destroy
können Sie den optionalen Versionsparameter angeben, um eine bestimmte Version zu verwalten. Zum Beispiel:
functions:secrets:access SECRET_NAME[@VERSION]
Für weitere Informationen zu diesen Vorgängen übergeben Sie -h
mit dem Befehl, um die CLI-Hilfe anzuzeigen.
Wie Geheimnisse abgerechnet werden
Secret Manager ermöglicht 6 aktive Secret- Versionen kostenlos. Das bedeutet, dass Sie kostenlos 6 Secrets pro Monat in einem Firebase-Projekt haben können.
Standardmäßig versucht die Firebase-CLI, gegebenenfalls nicht verwendete Secret-Versionen automatisch zu zerstören, beispielsweise wenn Sie Funktionen mit einer neuen Version des Secrets bereitstellen. Außerdem können Sie ungenutzte Geheimnisse aktiv bereinigen, indem Sie functions:secrets:destroy
und functions:secrets:prune
verwenden.
Secret Manager ermöglicht 10.000 nicht in Rechnung gestellte monatliche Zugriffsvorgänge auf ein Geheimnis. Funktionsinstanzen lesen bei jedem Kaltstart nur die in ihrem runWith
Parameter angegebenen Geheimnisse. Wenn Sie viele Funktionsinstanzen haben, die viele Geheimnisse lesen, kann Ihr Projekt diesen Freibetrag überschreiten, woraufhin Ihnen 0,03 US-Dollar pro 10.000 Zugriffsvorgänge berechnet werden.
Weitere Informationen finden Sie unter Secret Manager-Preise .
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 enthalten, die leicht unterschiedliche Werte für die Entwicklung und lokale Tests enthalten:
.env | .env.dev | .env.local |
PLANET=Erde PUBLIKUM=Menschen | PUBLIKUM=Entwicklermenschen | PUBLIKUM=Lokale Menschen |
Beim Start im lokalen Kontext lädt der Emulator die Umgebungsvariablen wie gezeigt:
$ firebase emulators:start
i emulators: Starting emulators: functions
# Starts emulator with following environment variables:
# PLANET=Earth
# AUDIENCE=Local Humans
Geheimnisse und Anmeldeinformationen im Cloud Functions-Emulator
Der Cloud Functions-Emulator unterstützt die Verwendung von Geheimnissen zum Speichern und Zugreifen auf vertrauliche Konfigurationsinformationen . Standardmäßig versucht der Emulator, mithilfe der Standardanmeldeinformationen der Anwendung 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-Emulatorunterstützung für Umgebungsvariablen können Sie Secrets-Werte überschreiben, indem Sie eine .secret.local
Datei einrichten. Dies erleichtert Ihnen das lokale Testen Ihrer Funktionen, insbesondere wenn Sie keinen Zugriff auf den geheimen Wert haben.
Migration von der Umgebungskonfiguration
Wenn Sie die Umgebungskonfiguration mit functions.config
verwendet haben, können Sie Ihre vorhandene Konfiguration als Umgebungsvariablen (im Dotenv- Format) migrieren. Die Firebase-CLI stellt einen Exportbefehl bereit, der die Konfiguration jedes in .firebaserc
Datei Ihres Verzeichnisses aufgeführten Alias oder Projekts (im folgenden Beispiel local
, dev
und prod
) als .env
Dateien ausgibt.
Exportieren Sie zum Migrieren Ihre vorhandenen Umgebungskonfigurationen mit dem 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
Beachten Sie, dass Sie in einigen Fällen aufgefordert werden, ein Präfix einzugeben, um exportierte Umgebungsvariablenschlüssel umzubenennen. Dies liegt daran, dass nicht alle Konfigurationen automatisch transformiert werden können, da sie möglicherweise ungültig sind oder ein reservierter Umgebungsvariablenschlüssel sind.
Wir empfehlen Ihnen, den Inhalt der generierten .env
Dateien sorgfältig zu überprüfen, bevor Sie Ihre Funktionen bereitstellen oder die .env
Dateien in die Quellcodeverwaltung einchecken. Wenn Werte vertraulich sind und nicht preisgegeben werden sollten, entfernen Sie sie aus Ihren .env
Dateien und speichern Sie sie stattdessen sicher im Secret Manager .
Sie müssen auch Ihren Funktionscode aktualisieren. Alle Funktionen, die functions.config
verwenden, müssen jetzt stattdessen process.env
verwenden, wie in „Upgrade auf die 2. Generation“ gezeigt.
Umgebungskonfiguration
Bevor die Unterstützung von Umgebungsvariablen in firebase-functions v3.18.0
veröffentlicht wurde, war die Verwendung von functions.config()
der empfohlene Ansatz für die Umgebungskonfiguration. Dieser Ansatz wird weiterhin unterstützt, wir empfehlen jedoch, dass bei allen neuen Projekten stattdessen Umgebungsvariablen verwendet werden, da diese einfacher zu verwenden sind und die Portabilität Ihres Codes verbessern.
Legen Sie die Umgebungskonfiguration mit der CLI fest
Um Umgebungsdaten zu speichern, können Sie den Befehl firebase functions:config:set
in der Firebase-CLI verwenden. Jeder Schlüssel kann mithilfe von Punkten mit einem Namensraum versehen werden, um verwandte Konfigurationen zu gruppieren. Beachten Sie, dass in Schlüsseln nur Kleinbuchstaben akzeptiert werden . Großbuchstaben sind nicht erlaubt.
Um beispielsweise die Client-ID und den API-Schlüssel für „Some Service“ zu speichern, können Sie Folgendes ausführen:
firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"
Rufen Sie die aktuelle Umgebungskonfiguration ab
Um zu überprüfen, was derzeit in der Umgebungskonfiguration für Ihr Projekt gespeichert ist, können Sie firebase functions:config:get
verwenden. Es wird JSON etwa so ausgeben:
{
"someservice": {
"key":"THE API KEY",
"id":"THE CLIENT ID"
}
}
Diese Funktionalität basiert auf der Google Cloud Runtime Configuration API .
Verwenden Sie functions.config
, um auf die Umgebungskonfiguration in einer Funktion zuzugreifen
Einige Konfigurationen werden automatisch im reservierten firebase
Namespace bereitgestellt. Die Umgebungskonfiguration wird innerhalb Ihrer laufenden Funktion über functions.config()
verfügbar gemacht. Um die obige Konfiguration zu verwenden, könnte Ihr Code so aussehen:
const functions = require('firebase-functions');
const request = require('request-promise');
exports.userCreated = functions.database.ref('/users/{id}').onWrite(event => {
let email = event.data.child('email').val();
return request({
url: 'https://someservice.com/api/some/call',
headers: {
'X-Client-ID': functions.config().someservice.id,
'Authorization': `Bearer ${functions.config().someservice.key}`
},
body: {email: email}
});
});
Verwenden Sie die Umgebungskonfiguration, um ein Modul zu initialisieren
Einige Node-Module sind ohne Konfiguration einsatzbereit. Andere Module benötigen eine zusätzliche Konfiguration, um korrekt zu initialisieren. Wir empfehlen Ihnen, diese Konfiguration in Umgebungskonfigurationsvariablen zu speichern, anstatt sie fest zu codieren. Dies trägt dazu bei, dass Ihr Code viel portabler bleibt, sodass Sie Ihre Anwendung als Open Source veröffentlichen oder problemlos zwischen Produktions- und Staging-Versionen wechseln können.
Um beispielsweise das Slack Node SDK- Modul zu verwenden, könnten Sie Folgendes schreiben:
const functions = require('firebase-functions');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);
Legen Sie vor der Bereitstellung die Umgebungskonfigurationsvariable slack.url
fest:
firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX
Zusätzliche Umgebungsbefehle
-
firebase functions:config:unset key1 key2
entfernt die angegebenen Schlüssel aus der Konfiguration -
firebase functions:config:clone --from <fromProject>
klont die Umgebung eines anderen Projekts in das aktuell aktive Projekt.
Automatisch ausgefüllte Umgebungsvariablen
Es gibt Umgebungsvariablen, die automatisch in der Funktionslaufzeit und in lokal emulierten Funktionen gefüllt werden. Dazu gehören diejenigen, die von Google Cloud ausgefüllt werden , sowie eine Firebase-spezifische Umgebungsvariable:
process.env.FIREBASE_CONFIG
: Stellt die folgenden Firebase-Projektkonfigurationsinformationen bereit:
{
databaseURL: 'https://databaseName.firebaseio.com',
storageBucket: 'projectId.appspot.com',
projectId: 'projectId'
}
Diese Konfiguration wird automatisch angewendet, wenn Sie das Firebase Admin SDK ohne Argumente initialisieren. Wenn Sie Funktionen in JavaScript schreiben, initialisieren Sie sie wie folgt:
const admin = require('firebase-admin');
admin.initializeApp();
Wenn Sie Funktionen in TypeScript schreiben, initialisieren Sie sie wie folgt:
import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
import 'firebase-functions';
admin.initializeApp();
Wenn Sie das Admin SDK mit der Standardprojektkonfiguration mithilfe von Dienstkonto-Anmeldeinformationen initialisieren müssen, können Sie die Anmeldeinformationen aus einer Datei laden und sie wie folgt 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);