Konfigurierung Ihrer Umgebung

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:

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

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

2. Öffnen Sie die .env Datei zum Bearbeiten und fügen Sie die gewünschten Schlüssel hinzu. Zum Beispiel:

   PLANET=Earth
   AUDIENCE=Humans
   

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

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

   firebase functions:secrets:set SECRET_NAME

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

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

3. 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
     });

4. 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);