Konfigurierung Ihrer Umgebung


Häufig ist eine zusätzliche Konfiguration für Ihre Funktionen erforderlich, z. B. API-Schlüssel von Drittanbietern oder anpassbare Einstellungen. Das Firebase SDK für Cloud Functions bietet eine integrierte Umgebungskonfiguration, mit der 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). So erhalten Sie eine stark typisierte Umgebungskonfiguration mit Parametern, die zum Zeitpunkt der Bereitstellung validiert werden. Das verhindert Fehler und vereinfacht die Fehlerbehebung.
  • Dateibasierte Konfiguration von Umgebungsvariablen Bei diesem Ansatz erstellen Sie manuell eine dotenv-Datei zum Laden von 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 deklarativen Definieren von Konfigurationsparametern in 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 Befehlszeile das Deployment blockiert, es sei denn, alle Parameter haben einen gültigen Wert.

So definieren Sie Parameter in Ihrem Code:

const functions = require('firebase-functions/v1');
const { defineInt, defineString } = require('firebase-functions/params');

// Define some parameters
const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

Wenn Sie eine Funktion mit parametrisierten Konfigurationsvariablen bereitstellen, versucht die Firebase CLI zuerst, ihre Werte aus lokalen .env-Dateien zu laden. Wenn sie nicht in diesen Dateien vorhanden sind und keine default festgelegt ist, werden Sie während der Bereitstellung von der Befehlszeile aufgefordert, die Werte anzugeben. Diese werden dann automatisch in einer .env-Datei mit dem Namen .env.<project_ID> im Verzeichnis functions/ gespeichert:

$ firebase deploy
i  functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i  functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i  functions: Loaded environment variables from .env.projectId

Je nach 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 im globalen Gültigkeitsbereich zu einem Bereitstellungsfehler führt. 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 festgelegt, um das Format einer Telefonnummer zu validieren, eine einfache Auswahloption bereitzustellen und eine Auswahloption automatisch 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 bei der Bereitstellung als auch während der Ausführung Ihrer Funktion aus. Aufgrund dieser doppelten Umgebungen müssen Sie beim Vergleichen von Parameterwerten und beim Festlegen von Laufzeitoptionen für Ihre Funktionen besonders vorsichtig sein.

Wenn Sie einen Parameter als Laufzeitoption an die Funktion übergeben möchten, übergeben Sie ihn direkt:

const functions = require('firebase-functions/v1');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

Wenn Sie einen Wert mit einem 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) => {
    //…

Auf Parameter und Parameterausdrücke, die nur zur Laufzeit verwendet werden, kann über die entsprechende value-Funktion zugegriffen werden:

const functions = require('firebase-functions/v1');
const { defineString } = require('firebase-functions/params');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.https.onRequest(
 (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

Integrierte Parameter

Das Cloud Functions SDK bietet drei vordefinierte Parameter, die über das Unterpaket firebase-functions/params verfügbar sind:

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

Sie funktionieren in jeder Hinsicht wie benutzerdefinierte Stringparameter, mit der Ausnahme, dass ihre Werte der Firebase-Befehlszeile immer bekannt sind und daher bei der Bereitstellung nicht abgefragt und nicht in .env-Dateien gespeichert werden.

Geheime Parameter

Parameter vom Typ Secret, die mit defineSecret() definiert sind, sind Stringparameter, deren Wert in Cloud Secret Manager gespeichert ist. Anstatt die Werte 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 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 das Dateiformat dotenv, um Umgebungsvariablen, die in einer .env-Datei angegeben sind, in die Anwendungslaufzeit zu laden. Nach der Bereitstellung können die Umgebungsvariablen über die process.env-Benutzeroberfläche gelesen werden.

Wenn Sie Ihre Umgebung so konfigurieren möchten, erstellen Sie eine .env-Datei in Ihrem Projekt, fügen Sie die gewünschten Variablen hinzu und führen Sie den Deployment aus:

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

    # 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. Funktionen bereitstellen und prüfen, 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 Umgebungsvariablen bereitstellen

Wenn Sie für Ihre Firebase-Projekte eine alternative Umgebungsvariablengruppe benötigen (z. B. für die Staging-Umgebung oder die Produktionsumgebung), erstellen Sie eine Datei .env.<project or alias> und schreiben Sie dort Ihre projektspezifischen Umgebungsvariablen. Die Umgebungsvariablen aus .env- und projektspezifischen .env-Dateien (falls vorhanden) werden in alle bereitgestellten Funktionen aufgenommen.

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=Earth

AUDIENCE=Mensch

AUDIENCE=Dev Humans AUDIENCE=Prod Humans

Je nach den Werten in diesen separaten Dateien variiert die Anzahl der 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 in Ihren .env-Dateien keine der folgenden Schlüssel:

  • Alle Schlüssel, die mit X_GOOGLE_ beginnen
  • Alle Schlüssel, die mit EXT_ beginnen
  • Alle Schlüssel, die mit FIREBASE_ beginnen
  • Beliebiger Schlüssel aus der folgenden Liste:
  • CLOUD_RUNTIME_CONFIG
  • ENTRY_POINT
  • GCP_PROJECT
  • GCLOUD_PROJECT
  • GOOGLE_CLOUD_PROJECT
  • FUNCTION_TRIGGER_TYPE
  • FUNCTION_NAME
  • FUNCTION_MEMORY_MB
  • FUNCTION_TIMEOUT_SEC
  • FUNCTION_IDENTITY
  • FUNCTION_REGION
  • FUNCTION_TARGET
  • FUNCTION_SIGNATURE_TYPE
  • K_SERVICE
  • K_REVISION
  • PORT
  • K_CONFIGURATION

Vertrauliche Konfigurationsinformationen speichern und darauf zugreifen

In .env-Dateien gespeicherte Umgebungsvariablen können für die Funktionskonfiguration verwendet werden. Sie 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 die Versionsverwaltung einchecken.

Cloud Functions for Firebase kann mit Google Cloud Secret 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.

    In der Befehlszeile wird eine Erfolgsmeldung angezeigt und Sie werden darauf hingewiesen, 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

Sie können jetzt wie bei jeder anderen Umgebungsvariablen 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
  });

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

Secrets verwalten

Verwalten Sie Ihre Secrets mit der Firebase CLI. Beachten Sie beim Verwalten von Geheimnissen auf diese Weise, dass Sie bei einigen Befehlszeilenänderungen die zugehörigen Funktionen ändern und/oder neu bereitstellen müssen. Zum Beispiel:

  • Wenn Sie einen neuen Wert für ein Secret festlegen, müssen Sie alle Funktionen, die auf dieses Secret verweisen, neu bereitstellen, 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 den optionalen Versionsparameter angeben, um eine bestimmte Version zu verwalten. Beispiel:

functions:secrets:access SECRET_NAME[@VERSION]

Weitere Informationen zu diesen Vorgängen erhalten Sie, wenn Sie -h mit dem Befehl übergeben, um die Befehlszeilenhilfe aufzurufen.

Abrechnung von Secrets

Mit Secret Manager können Sie kostenlos 6 aktive Secret-Versionen verwenden. Das bedeutet, dass Sie in einem Firebase-Projekt kostenlos sechs Secrets pro Monat verwenden können.

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.

Mit Secret Manager sind 10.000 nicht in Rechnung gestellte Zugriffe pro Monat auf ein Secret zulässig. 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 Begrenzung 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.

Emulatorunterstützung

Die Umgebungskonfiguration mit dotenv ist für die Interkonnektivität 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 die folgenden drei Dateien mit leicht unterschiedlichen Werten für die Entwicklung und lokale Tests enthalten:

.env .env.dev .env.local
PLANET=Earth

AUDIENCE=Mensch

AUDIENCE=Dev Humans AUDIENCE=Local Humans

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 zum Speichern und Abrufen vertraulicher Konfigurationsinformationen. Standardmäßig versucht der Emulator, mit den Standardanmeldedaten für Anwendungen auf Ihre Produktions-Secrets zuzugreifen. In bestimmten Situationen, z. B. in CI-Umgebungen, kann der Emulator aufgrund von Berechtigungseinschränkungen 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 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, können Sie Ihre vorhandene Konfiguration als Umgebungsvariablen (im dotenv-Format) migrieren. Die Firebase-Befehlszeile bietet einen Exportbefehl, mit dem die Konfiguration jedes Alias oder Projekts ausgegeben wird, das in der .firebaserc-Datei Ihres Verzeichnisses aufgeführt ist (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 können, da sie ungültig sein oder einen reservierten Umgebungsvariablenschlüssel enthalten können.

Wir empfehlen Ihnen, den Inhalt der generierten .env-Dateien sorgfältig zu prüfen, bevor Sie Ihre Funktionen bereitstellen oder die .env-Dateien in die Versionskontrolle aufnehmen. 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. Alle Funktionen, in denen functions.config verwendet wird, müssen jetzt stattdessen process.env verwenden, wie im Abschnitt Auf die 2. Generation umstellen beschrieben.

Umgebungskonfiguration

Umgebungskonfiguration mit der Befehlszeile festlegen

Zum Speichern von Umgebungsdaten können Sie den Befehl firebase functions:config:set in der Firebase-Befehlszeile verwenden. Jeder Schlüssel kann mithilfe von Punkten einen eigenen Namensbereich erhalten, um zugehörige Konfigurationen zu gruppieren. In Schlüsseln sind nur Kleinbuchstaben zulässig. Großbuchstaben sind nicht erlaubt.

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 in einer Funktion verwenden, um auf die Umgebungskonfiguration zuzugreifen

Einige Konfigurationen werden automatisch im reservierten Namespace firebase bereitgestellt. Die Umgebungskonfiguration wird in Ihrer laufenden Funktion über functions.config() verfügbar gemacht. Wenn Sie die oben genannte Konfiguration verwenden möchten, könnte Ihr Code so aussehen:

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 Slack Node SDK-Modul 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

Weitere Befehle für die Umgebung

  • 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 von Google Cloud ausgefüllte Variablen sowie eine Firebase-spezifische Umgebungsvariable:

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

{
  databaseURL: 'https://DATABASE_NAME.firebaseio.com',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  projectId: 'PROJECT_ID'
}

Die Werte in Ihrer tatsächlichen Firebase-Konfiguration können je nach den in Ihrem Projekt bereitgestellten Ressourcen variieren.

Diese Konfiguration wird automatisch angewendet, wenn Sie das Firebase Admin SDK ohne Argumente initialisieren. Wenn Sie Funktionen in JavaScript schreiben, initialisieren Sie sie so:

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

Wenn Sie Funktionen in TypeScript schreiben, initialisieren Sie sie so:

import * as functions from 'firebase-functions/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
admin.initializeApp();

Wenn Sie das Admin SDK mit der Standardprojektkonfiguration und den Anmeldedaten 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);