Konfigurierung Ihrer Umgebung


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 integrierten Umgebungskonfiguration, um das Speichern und Abrufen Art der Daten für Ihr Projekt.

Sie können zwischen folgenden Optionen wählen:

  • Parametrisierte 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. Dieser Ansatz Konfigurationswerte sowohl zur Laufzeit als auch zur Bereitstellung verfügbar machen und Die Bereitstellung wird blockiert, sofern 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 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 es sei denn, alle Parameter haben einen gültigen Wert.

Folgen Sie diesem Modell, um Parameter in Ihrem Code zu definieren:

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

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 kein default festgelegt ist, fordert die Befehlszeile die Werte während der Bereitstellung und speichern sie automatisch in einem .env-Datei mit dem Namen .env.<project_ID> im 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 Versionsverwaltung hinzuzufügen.

Parameter im globalen Gültigkeitsbereich verwenden

Während der Bereitstellung wird der Funktionscode geladen und geprüft, Parameter haben tatsächliche Werte. Das bedeutet, dass das Abrufen von Parameterwerten globalen Umfang führt dazu, dass die Bereitstellung fehlschlägt. Wenn Sie eine -Parameter zum Initialisieren eines globalen Werts verwenden, 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.

  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());
  })

Befehlszeilenverhalten konfigurieren

Parameter können mit einem Options-Objekt konfiguriert werden, das steuert, wie die Befehlszeile werden nach Werten gefragt. Im folgenden Beispiel werden Optionen zur Validierung des Format einer Telefonnummer, um eine einfache Auswahlmöglichkeit zu bieten, und automatisch eine Auswahloption aus dem Firebase-Projekt auszufü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 ermöglicht eine starke Typisierung von Parameterwerten und unterstützen auch Secrets von Cloud Secret Manager. Unterstützte Typen sind:

  • Secret
  • String
  • Boolesch
  • Ganzzahl
  • Float

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

Um einen Parameter als Laufzeitoption an Ihre Funktion zu übergeben, ü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 mit einem Parameter vergleichen müssen, müssen Sie integrierte Vergleichsoperatoren verwenden, Überprüfen des Werts:

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) => {
    //…

Parameter und Parameterausdrücke, die nur während der Laufzeit verwendet werden, können Zugriff mit der value-Funktion:

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 von dem Teilpaket firebase-functions/params:

  • projectID: das Cloud-Projekt, in dem die Funktion ausgeführt wird.
  • databaseURL – die URL der verknüpften Realtime Database-Instanz mit der Funktion (sofern im Firebase-Projekt aktiviert).
  • storageBucket: Der Cloud Storage-Bucket, der der Funktion zugewiesen ist (sofern im Firebase-Projekt aktiviert).

Sie funktionieren wie ein benutzerdefinierter String in allen Aspekten zu verwenden, außer dass, da ihre Werte immer bekannt sind über die Firebase CLI festlegen, werden ihre Werte weder bei der Bereitstellung noch in .env Dateien gespeichert.

Secret-Parameter

Parameter des Typs Secret, definiert mit defineSecret(), stellen einen String dar Parameter, 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 werden, die auf sie zugreifen können:

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();
    //…

Da die Werte von Geheimnissen bis zur Ausführung der Funktion ausgeblendet sind, können Sie sie nicht bei der Konfiguration der Funktion verwenden.

Umgebungsvariablen

Cloud Functions for Firebase unterstützt die dotenv Dateiformat zum Laden von Umgebungsvariablen, die in einer .env-Datei angegeben sind, in Ihren Anwendungslaufzeit. Nach der Bereitstellung können die Umgebungsvariablen über die process.env-Benutzeroberfläche gelesen werden.

Wenn Sie Ihre Umgebung auf diese Weise konfigurieren möchten, erstellen Sie eine .env-Datei in Ihrem Projekt. Fügen Sie die gewünschten Variablen hinzu und stellen Sie Folgendes bereit:

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

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

  2. Öffnen Sie die Datei .env zur Bearbeitung und fügen Sie die gewünschten Schlüssel hinzu. Beispiel:

    PLANET=Earth
AUDIENCE=Humans

  3. Stellen Sie Funktionen bereit und prüfen Sie, ob Umgebungsvariablen geladen wurden:

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

Nachdem Ihre benutzerdefinierten Umgebungsvariablen bereitgestellt wurden, 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 Gruppen von 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 aus .env- und projektspezifischen .env-Dateien (falls vorhanden) werden in alle bereitgestellten Funktionen aufgenommen.

Ein Projekt könnte z. B. diese drei Dateien enthalten, unterschiedliche Werte für Entwicklung und Produktion:

.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 Schlüssel für Umgebungsvariablen sind für die interne Verwendung reserviert. Verwenden Sie keines der folgenden folgende Schlüssel in Ihren .env-Dateien:

  • Alle Schlüssel, die mit X_GOOGLE_ beginnen
  • Alle Schlüssel ab EXT_
  • Alle Schlüssel, die mit FIREBASE_ beginnen
  • Jeder Schlüssel aus der folgenden Liste:
  • CLOUD_RUNTIME_CONFIG
  • EINSTIEGSPUNKT
  • Google Cloud-Projekt
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • FUNKTIONSTRIGGER_TYP
  • FUNKTIONSNAME
  • FUNKTIONSMEMORY_MB
  • FUNKTION_TIMEOUT_SEC
  • FUNKTIONS-IDENTITÄT
  • FUNKTIONSREGION
  • FUNKTIONSZIEL
  • FUNKTIONSSIGNATURE_TYPE
  • K_SERVICE
  • K_REVISION
  • Port
  • K_CONFIGURATION

Vertrauliche Konfigurationsinformationen speichern und darauf zugreifen

In .env-Dateien gespeicherte Umgebungsvariablen können für Funktionen verwendet werden Konfiguration, aber Sie sollten sie nicht als sichere Methode zum Speichern vertraulicher Informationen wie Datenbankanmeldedaten oder API-Schlüssel. 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:

  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 Befehlszeile gibt eine Erfolgsmeldung aus und warnt, dass Sie Funktionen bereitstellen müssen damit die Änderung wirksam wird.

  3. Prüfen Sie vor der Bereitstellung, ob der Funktionscode der Funktion den Zugriff auf das Secret mit dem Parameter runWith 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. Stellen Sie Cloud Functions bereit:

    firebase deploy --only functions

Jetzt können Sie wie auf jede andere Umgebungsvariable darauf zugreifen. Wenn dagegen eine andere Funktion, die das Secret nicht in runWith angibt, versucht, auf das Secret zuzugreifen, wird ein nicht definierter Wert zurückgegeben:

  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 die Funktion bereitgestellt ist, hat sie Zugriff auf den Secret-Wert. Nur Funktionen, die im runWith-Parameter ein Secret enthalten, haben Zugriff auf dieses Secret als Umgebungsvariable. So können Sie 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, die auf um den neuesten Wert zu erfassen.
  • Achten Sie beim Löschen eines Secrets darauf, dass keine der bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten geheimen Wert verwenden, schlagen geräuschlos fehl.

Im Folgenden finden Sie eine Zusammenfassung der Firebase-Befehlszeilenbefehle für die Secret-Verwaltung:

# Change the value of an existing secret
firebase functions:secrets:set SECRET_NAME

# View the value of a secret
functions:secrets:access SECRET_NAME

# Destroy a secret
functions:secrets:destroy SECRET_NAME

# View all secret versions and their state
functions:secrets:get SECRET_NAME

# Automatically clean up all secrets that aren't referenced by any of your functions
functions:secrets:prune

Für die Befehle access und destroy können Sie 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

Secret Manager lässt 6 aktive Secrets zu Versionen kostenlos. Sie können also sechs Secrets pro Monat in einem Firebase-Projekt kostenlos.

Standardmäßig versucht die Firebase-Befehlszeile, nicht verwendetes Secret automatisch zu löschen Versionen, z. B. wenn Sie Funktionen mit einer neuen Version bereitstellen des Geheimnisses. Außerdem können Sie nicht verwendete Secrets aktiv mit functions:secrets:destroy und functions:secrets:prune.

Secret Manager ermöglicht 10.000 nicht abgerechnete monatliche Zugriffsvorgänge auf einem geheim halten. Funktionsinstanzen lesen nur die in ihrer 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 Secret Manager-Preise.

Emulator-Unterstützung

Die Umgebungskonfiguration mit "dotenv" ist für die Interoperabilität mit einem lokalen Cloud Functions-Emulator.

Wenn Sie einen lokalen Cloud Functions-Emulator verwenden, können Sie die Umgebung überschreiben Variablen für Ihr Projekt verwenden, 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 enthalten, unterschiedliche Werte für Entwicklung und lokale Tests:

.env .env.dev .env.local
PLANET=Erde

ZIELGRUPPE=Menschen

AUDIENCE=Entwicklermenschen AUDIENCE=Menschen vor Ort

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

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

Secrets und Anmeldedaten im Cloud Functions-Emulator

Der Cloud Functions-Emulator unterstützt die Verwendung von Secrets für Vertrauliche Konfigurationsinformationen speichern und darauf zugreifen. Standardmäßig versucht der Emulator, mit der folgenden Methode auf Ihre Produktions-Secrets zuzugreifen: Standardanmeldedaten für Anwendungen. In bestimmten Situationen, z. B. in CI-Umgebungen, greift der Emulator möglicherweise nicht auf Secret-Werte aufgrund von Berechtigungseinschränkungen.

Ähnlich wie bei der Unterstützung des Cloud Functions-Emulators für Umgebungsvariablen können Sie Secret-Werte durch Einrichten einer .secret.local-Datei überschreiben. So können Sie Ihre Funktionen ganz einfach lokal testen, insbesondere wenn Sie keinen Zugriff auf den geheimen Wert haben.

Von der Umgebungskonfiguration migrieren

Wenn Sie die Umgebungskonfiguration mit functions.config verwendet haben, Ihre vorhandene Konfiguration als Umgebungsvariablen (in dotenv-Format). Die Firebase-Befehlszeile bietet einen Exportbefehl, der die Konfiguration ausgibt, jedes in der Datei .firebaserc Ihres Verzeichnisses aufgeführten Alias oder Projekts (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

Beachten Sie, dass Sie in einigen Fällen aufgefordert werden, ein Präfix zum Umbenennen exportierten Umgebungsvariablenschlüssel. 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 Funktionscode aktualisieren. Für alle Funktionen, in denen functions.config verwendet wird, muss jetzt stattdessen process.env verwendet werden, wie im Abschnitt Auf die 2. Generation umstellen beschrieben.

Umgebungskonfiguration

Umgebungskonfiguration über die Befehlszeile festlegen

Zum Speichern von Umgebungsdaten können Sie die firebase functions:config:set verwenden. in der Firebase-Befehlszeile. Jeder Schlüssel kann mithilfe von Punkten in einen Namespace aufgenommen werden, um verwandte Elemente zu gruppieren zusammen. Denken Sie daran, dass nur Kleinbuchstaben in Schlüsseln akzeptiert; Großbuchstaben sind nicht zulässig.

Um beispielsweise die Client-ID und den API-Schlüssel für "Einige Dienste" ausgeführt haben, können Sie Folgendes ausführen:

firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"

Aktuelle Umgebungskonfiguration abrufen

Um zu prüfen, was derzeit in der Umgebungskonfiguration für Ihr Projekt gespeichert ist, kann firebase functions:config:get verwenden. Es gibt in etwa im JSON-Format dies:

{
  "someservice": {
    "key":"THE API KEY",
    "id":"THE CLIENT ID"
  }
}

Diese Funktion basiert auf dem Google Cloud Runtime Configuration API.

Mit functions.config auf die Umgebungskonfiguration in einer Funktion zugreifen

Ein Teil der Konfiguration wird automatisch unter der reservierten firebase bereitgestellt. -Namespace auf sie zugegriffen werden. Die Umgebungskonfiguration wird in Ihrer laufenden über functions.config(). Ihr Code könnte wie folgt aussehen, um die obige Konfiguration zu verwenden:

const functions = require('firebase-functions/v1');
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}
  });
});

Umgebungskonfiguration zum Initialisieren eines Moduls verwenden

Einige Node-Module sind ohne Konfiguration einsatzbereit. Für andere Module sind zusätzliche damit es korrekt initialisiert wird. Wir empfehlen, diese Konfiguration in Umgebungskonfigurationsvariablen zu speichern, anstatt sie zu hartcodieren. Das hilft, So bleibt Ihr Code portierbarer. So können Sie Ihr oder zwischen Produktions- und Staging-Versionen wechseln.

Wenn Sie beispielsweise das Modul Slack Node SDK verwenden möchten, könnten Sie Folgendes schreiben:

const functions = require('firebase-functions/v1');
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 derzeit aktive Projekt.

Automatisch ausgefüllte Umgebungsvariablen

Im Bereich und in lokal emulierten Funktionen. Dazu gehören: mit den Werten von Google Cloud, sowie eine Firebase-spezifische Umgebungsvariable erstellen:

process.env.FIREBASE_CONFIG: stellt die folgenden Informationen zur Firebase-Projektkonfiguration bereit:

{
  databaseURL: 'https://databaseName.firebaseio.com',
  storageBucket: 'projectId.appspot.com',
  projectId: 'projectId'
}

Diese Konfiguration wird automatisch angewendet, wenn Sie Firebase initialisieren Admin SDK ohne Argumente. 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 diese wie folgt:

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 eines Dienstkontos initialisieren möchten, können Sie die Anmeldedaten aus einer Datei laden und FIREBASE_CONFIG so hinzufügen:

serviceAccount = require('./serviceAccount.json');

const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);