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 eine integrierte Umgebungskonfiguration, mit der sich diese Art von Daten für Ihr Projekt ganz einfach speichern und abrufen lassen.

Sie haben folgende Möglichkeiten:

  • Parametriserte Konfiguration (für die meisten Szenarien empfohlen). Dies bietet eine stark typisierte Umgebung Konfiguration mit Parametern, die zum Zeitpunkt der Bereitstellung validiert werden. verhindert Fehler und vereinfacht die Fehlerbehebung.
  • Dateibasierte Konfiguration von Umgebungsvariablen Bei diesem Ansatz erstellen Sie manuell ein dotenv-Datei zum Laden Umgebungsvariablen.

Für die meisten Anwendungsfälle wird eine parametrisierte Konfiguration empfohlen. Bei diesem Ansatz sind Konfigurationswerte sowohl zur Laufzeit als auch zum Zeitpunkt der Bereitstellung verfügbar. Die Bereitstellung wird blockiert, es sei denn, alle Parameter haben einen gültigen Wert. Umgekehrt ist die Konfiguration mit Umgebungsvariablen beim Bereitstellen nicht verfügbar.

Parametrisierte Konfiguration

Cloud Functions for Firebase bietet eine Schnittstelle zum Definieren der Konfiguration deklarativ in Ihrer Codebasis. Der Wert dieser Parameter ist sowohl während der Funktionsbereitstellung als auch beim Festlegen der Bereitstellung und der Laufzeit verfügbar. und bei der Ausführung. Das bedeutet, dass die Befehlszeile sofern alle Parameter einen gültigen Wert haben.

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

Je nach Entwicklungsablauf kann es sinnvoll sein, die generierte .env.<project_ID>-Datei der Versionskontrolle hinzuzufügen.

Parameter im globalen Gültigkeitsbereich verwenden

Während der Bereitstellung wird der Code Ihrer Funktion geladen und geprüft, bevor Ihre Parameter tatsächliche Werte haben. Das bedeutet, dass das Abrufen von Parameterwerten globalen Umfang führt dazu, dass die Bereitstellung fehlschlägt. Wenn Sie einen Parameter verwenden möchten, um einen globalen Wert zu initialisieren, verwenden Sie den Initialisierungs-Callback onInit(). Dieser Callback wird ausgeführt, bevor Funktionen in der Produktion ausgeführt werden, aber nicht während der Bereitstellung. Daher ist es ein sicherer Ort, um auf den Wert eines Parameters zuzugreifen.

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

Verhalten der Befehlszeile konfigurieren

Parameter können mit einem Options-Objekt konfiguriert werden, das steuert, wie in der Befehlszeile nach Werten gefragt wird. 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 bietet eine strenge Typisierung für Parameterwerte und unterstützt auch Secrets aus Cloud Secret Manager. Folgende Typen werden unterstützt:

  • Secret
  • String
  • Boolesch
  • Ganzzahl
  • Float

Parameterwerte und ‑ausdrücke

Firebase wertet Ihre Parameter sowohl zum Zeitpunkt der Bereitstellung als auch während der Funktion aus ausgeführt wird. Aufgrund dieser doppelten Umgebungen müssen Sie beim Vergleichen von Parameterwerten und beim Festlegen von Laufzeitoptionen für Ihre Funktionen besonders vorsichtig sein.

Um einen Parameter als Laufzeitoption an Ihre Funktion zu übergeben, übergeben Sie ihn direkt:

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 einen Parameter vergleichen müssen, um zu wissen, welche Option Sie auswählen sollen, müssen Sie integrierte Vergleichsoperatoren 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) => {
    //…

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 über das Unterpaket firebase-functions/params verfügbar sind:

  • 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 mit der Funktion verknüpfte Cloud Storage-Bucket (sofern im Firebase-Projekt aktiviert).

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

Secret-Parameter

Parameter vom Typ Secret, die mit defineSecret() definiert sind, sind Stringparameter, deren Wert in Cloud Secret Manager gespeichert ist. Anstatt sie mit einer lokalen .env-Datei zu vergleichen und bei Bedarf einen neuen Wert in die Datei zu schreiben, wird bei Secret-Parametern geprüft, ob sie in Cloud Secret Manager vorhanden sind. Während der Bereitstellung wird dann interaktiv nach dem Wert eines neuen Secrets gefragt.

Auf diese Weise definierte Secret-Parameter müssen an einzelne Funktionen gebunden sein, die Zugriff darauf haben sollen:

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 Secrets bis zur Ausführung der Funktion verborgen sind, kann bei der Konfiguration der Funktion nicht verwendet werden.

Umgebungsvariablen

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

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 eine .env-Datei in Ihrem functions/-Verzeichnis:

    # 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.
# ...

Sobald Ihre benutzerdefinierten Umgebungsvariablen bereitgestellt sind, kann Ihr Funktionscode process.env Syntax:

// 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 beispielsweise die folgenden drei Dateien enthalten, die leicht unterschiedliche Werte für Entwicklung und Produktion enthalten:

.env .env.dev .env.prod
PLANET=Erde

ZIELGRUPPE=Menschen

AUDIENCE=Entwicklermenschen AUDIENCE=Prod Humans

Angesichts der Werte in diesen separaten Dateien die mit Ihren Funktionen bereitgestellt wurden, hängt vom Zielprojekt ab:

$ firebase use dev
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.dev.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Dev Humans

$ firebase use prod
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.prod.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Prod Humans

Reservierte Umgebungsvariablen

Einige Umgebungsvariablenschlüssel sind für die interne Verwendung reserviert. Verwenden Sie in Ihren .env-Dateien keine der folgenden Schlüssel:

  • Alle Schlüssel, die mit X_GOOGLE_ beginnen
  • Alle Schlüssel ab EXT_
  • Alle Schlüssel, die mit FIREBASE_ beginnen
  • Beliebiger Schlüssel aus der folgenden Liste:
  • CLOUD_RUNTIME_CONFIG
  • EINSTIEGSPUNKT
  • GCP_PROJECT
  • GCLOUD-PROJEKT
  • GOOGLE_CLOUD_PROJECT
  • FUNCTION_TRIGGER_TYPE
  • FUNCTION_NAME
  • FUNKTIONSMEMORY_MB
  • FUNKTION_TIMEOUT_SEC
  • FUNCTION_IDENTITY
  • FUNKTIONSREGION
  • FUNCTION_TARGET
  • FUNKTIONSSIGNATURE_TYPE
  • K_SERVICE
  • K_REVISION
  • PORT
  • K_CONFIGURATION

Vertrauliche Konfigurationsinformationen speichern und darauf zugreifen

In .env-Dateien gespeicherte Umgebungsvariablen können für die Funktionskonfiguration verwendet werden. Sie sind jedoch keine sichere Möglichkeit, vertrauliche Informationen wie Datenbankanmeldedaten oder API-Schlüssel zu speichern. Das ist besonders wichtig, wenn Sie Ihre .env-Dateien in der Versionsverwaltung überprüfen.

Cloud Functions for Firebase kann mit Google CloudSecret Manager verbunden werden, um vertrauliche Konfigurationsinformationen zu speichern. Dieser verschlüsselte Dienst speichert Konfigurationswerte sicher und ermöglicht bei Bedarf dennoch einfachen Zugriff über Ihre Funktionen.

Secret erstellen und verwenden

Verwenden Sie die Firebase CLI, um ein Secret zu erstellen.

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. Achten Sie vor der Bereitstellung darauf, dass der Code der Funktion den Zugriff auf das Secret über den Parameter runWith zulässt:

    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 Functions bereitstellen:

    firebase deploy --only functions

Jetzt können Sie wie auf jede andere Umgebungsvariable darauf zugreifen. Wenn dagegen eine andere Funktion, die das Secret in runWith versucht, auf das Secret zuzugreifen, und erhält einen undefinierten Wert:

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

Nach der Bereitstellung hat die Funktion Zugriff auf den geheimen Wert. Nur für Funktionen, die im runWith-Parameter ein Secret enthalten, Zugriff auf das Secret als Umgebungsvariable haben. So können Sie sicherstellen, dass Secret-Werte nur dort verfügbar sind, wo sie benötigt werden. Dadurch wird das Risiko versehentlich ein Secret preisgibt.

Secrets verwalten

Verwenden Sie die Firebase-Befehlszeile, um Ihre Secrets zu verwalten. Wenn Sie Secrets auf diese Weise verwalten, Beachten Sie, dass Sie einige Änderungen an der Befehlszeile anpassen und/oder noch einmal bereitstellen müssen verbundenen Funktionen. Zum Beispiel:

  • Wenn Sie einen neuen Wert für ein Secret festlegen, müssen Sie alle Funktionen neu bereitstellen, die auf dieses Secret verweisen, damit sie den neuesten Wert abrufen können.
  • Wenn Sie ein Secret löschen, achten Sie darauf, dass keine Ihrer bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten geheimen Wert verwenden, schlagen geräuschlos fehl.

Hier eine Zusammenfassung der Firebase-Befehle der Befehlszeile für die Secret-Verwaltung:

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

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

# Destroy a secret
functions:secrets:destroy SECRET_NAME

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

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

Für die Befehle access und destroy können Sie die optionale Version um eine bestimmte Version zu verwalten. Beispiel:

functions:secrets:access SECRET_NAME[@VERSION]

Weitere Informationen zu diesen Vorgängen erhalten Sie, wenn Sie -h mit dem Befehl an CLI-Hilfe ansehen.

Abrechnung von Secrets

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 CLI, nicht verwendete Secret-Versionen bei Bedarf automatisch zu löschen, z. B. wenn Sie Funktionen mit einer neuen Version des Secrets bereitstellen. Außerdem können Sie nicht verwendete Secrets mit functions:secrets:destroy und functions:secrets:prune aktiv bereinigen.

Secret Manager ermöglicht 10.000 nicht abgerechnete monatliche Zugriffsvorgänge auf einem geheim halten. Funktionsinstanzen lesen bei jedem Kaltstart nur die im runWith-Parameter angegebenen Geheimnisse. Wenn Sie viele Funktionsinstanzen haben, die viele Secrets lesen, wird Ihr Projekt diese Zulage möglicherweise überschreiten. 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 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. Der Inhalt von .env.local hat Vorrang vor .env und der projektspezifischen .env-Datei.

Ein Projekt könnte z. B. diese drei Dateien mit geringfügig unterschiedliche Werte für Entwicklung und lokale Tests:

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

ZIELGRUPPE=Menschen

AUDIENCE=Dev Humans AUDIENCE=Menschen vor Ort

Beim Start im lokalen Kontext lädt der Emulator die Umgebung. Variablen wie hier zu sehen:

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

Secrets und Anmeldedaten im Cloud Functions-Emulator

Der Cloud Functions-Emulator unterstützt die Verwendung von Secrets zum Speichern und Abrufen vertraulicher Konfigurationsinformationen. 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, kann der Emulator aufgrund von Berechtigungseinschränkungen nicht auf geheime Werte zugreifen.

Ähnlich wie bei der Cloud Functions-Emulatorunterstützung für Umgebungsvariablen können Sie Geheimdatenwerte überschreiben, indem Sie eine .secret.local-Datei einrichten. So können Sie Ihre Funktionen einfach lokal zu testen, insbesondere wenn Sie keinen Zugriff mit dem Secret-Wert.

Aus der Umgebungskonfiguration migrieren

Wenn Sie die Umgebungskonfiguration mit functions.config verwendet haben, können Sie Ihre vorhandene Konfiguration als Umgebungsvariablen (im dotenv-Format) migrieren. Die Firebase-Befehlszeile bietet einen Exportbefehl, 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

In einigen Fällen werden Sie aufgefordert, ein Präfix einzugeben, um die exportierten Umgebungsvariablenschlüssel umzubenennen. Das liegt daran, dass nicht alle Konfigurationen automatisch umgewandelt werden, da sie ungültig oder reservierten Schlüssel der Umgebungsvariablen.

Wir empfehlen dir, den Inhalt der generierten .env-Dateien sorgfältig zu prüfen bevor Sie die Funktionen bereitstellen oder die .env-Dateien in der Versionsverwaltung einchecken. Wenn Werte vertraulich sind und nicht weitergegeben werden dürfen, entfernen Sie sie aus Ihren .env-Dateien und speichern Sie sie stattdessen sicher in Secret Manager.

Außerdem müssen Sie den Code Ihrer Funktionen aktualisieren. Für alle Funktionen, in denen functions.config verwendet wird, muss jetzt stattdessen process.env verwendet werden, wie 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. Beachten Sie, dass nur Kleinbuchstaben in Schlüsseln akzeptiert; Großbuchstaben sind nicht zulässig.

Wenn Sie beispielsweise die Client-ID und den API-Schlüssel für „Ein bestimmter Dienst“ speichern möchten, können Sie Folgendes ausführen:

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

Aktuelle Umgebungskonfiguration abrufen

Mit firebase functions:config:get können Sie prüfen, was derzeit in der Umgebungskonfiguration für Ihr Projekt gespeichert ist. Die JSON-Ausgabe sieht in etwa so aus:

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

Diese Funktion basiert auf der Google Cloud Runtime Configuration API.

functions.config verwenden, um in einer Funktion auf die Umgebungskonfiguration zuzugreifen

Ein Teil der Konfiguration wird automatisch unter der reservierten firebase bereitgestellt. -Namespace auf sie zugegriffen werden. Die Umgebungskonfiguration wird in Ihrer laufenden Funktion über functions.config() verfügbar gemacht. 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. Andere Module erfordern eine zusätzliche Konfiguration, um richtig initialisiert zu werden. Wir empfehlen, diese Konfiguration in Umgebungskonfigurationsvariablen zu speichern, anstatt sie zu hartcodieren. So können Sie Ihren Code viel einfacher portieren, Ihre Anwendung Open Source machen oder ganz einfach 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

Es gibt Umgebungsvariablen, die automatisch in der Funktionslaufzeit und in lokal emulierten Funktionen ausgefüllt werden. Dazu gehören: mit den Werten von Google Cloud, sowie eine Firebase-spezifische Umgebungsvariable erstellen:

process.env.FIREBASE_CONFIG: Enthält die folgenden Informationen zur Firebase-Projektkonfiguration:

{
  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, zu initialisieren:

const admin = require('firebase-admin');
admin.initializeApp();

Wenn Sie Funktionen in TypeScript schreiben, initialisieren Sie 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 Standard-Projektkonfiguration initialisieren müssen können Sie die Anmeldedaten aus einer Datei laden und So fügen Sie sie FIREBASE_CONFIG hinzu:

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

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