Konfigurierung Ihrer Umgebung


Häufig ist eine zusätzliche Konfiguration für Funktionen erforderlich, z. B. API-Schlüssel von Drittanbietern oder anpassbare Einstellungen. Das Firebase SDK for Cloud Functions bietet eine integrierte Umgebungskonfiguration, mit der Sie diese Art von Daten für Ihr Projekt einfach speichern und abrufen können.

Sie können zwischen drei Optionen wählen:

  • Parameterisierte Konfiguration (für die meisten Szenarien empfohlen): Dadurch wird eine stark typisierte Umgebungskonfiguration mit Parametern bereitgestellt, die zum Zeitpunkt der Bereitstellung validiert werden. Dadurch werden Fehler vermieden und die Fehlerbehebung wird 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. Dadurch sind Konfigurationswerte sowohl zur Laufzeit als auch zum Zeitpunkt der Bereitstellung verfügbar. Das Deployment wird blockiert, sofern nicht alle Parameter einen gültigen Wert haben. Umgekehrt ist eine Konfiguration mit Umgebungsvariablen bei der Bereitstellung 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 der Bereitstellungs- und Laufzeitoptionen als auch während der Ausführung verfügbar. Das bedeutet, dass die Befehlszeile die Bereitstellung blockiert, sofern nicht alle Parameter einen gültigen Wert haben.

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

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 zuerst, die Werte aus lokalen .env-Dateien zu laden. Wenn sie in diesen Dateien nicht vorhanden sind und kein default festgelegt ist, fordert die Befehlszeile die Werte während der Bereitstellung an und speichert die Werte dann automatisch in einer .env-Datei mit dem Namen .env.<project_ID> in Ihrem functions/-Verzeichnis:

$ 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 Ihrem Entwicklungsworkflow kann es sinnvoll sein, die generierte .env.<project_ID>-Datei der Versionsverwaltung hinzuzufügen.

Verhalten der Befehlszeile konfigurieren

Parameter können mit einem Options-Objekt konfiguriert werden, das steuert, wie die Befehlszeile Werte anfordert. 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 starke Typisierung von Parameterwerten und unterstützt auch Secrets von Cloud Secret Manager. Unterstützte Typen sind:

  • Secret
  • String
  • Boolesch
  • Ganzzahl
  • Gleitkommazahl

Parameterwerte und -ausdrücke

Firebase wertet Ihre Parameter sowohl zum Zeitpunkt der Bereitstellung als auch während der Ausführung der Funktion aus. Aufgrund dieser doppelten Umgebungen ist besondere Vorsicht beim Vergleich von Parameterwerten und deren Verwendung zum Festlegen von Laufzeitoptionen für Funktionen erforderlich.

Um einen Parameter als Laufzeitoption an die 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 Vergleich mit einem Parameter durchführen müssen, um zu ermitteln, welche Option Sie auswählen sollen, müssen Sie integrierte Komparatoren verwenden, anstatt den Wert zu prü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 die Funktion 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.`);
  }
);

Integrierte Parameter

Das Cloud Functions SDK bietet drei vordefinierte Parameter, die aus dem Teilpaket 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 der Funktion zugeordnet ist (falls im Firebase-Projekt aktiviert).
  • storageBucket: Der Cloud Storage-Bucket, der der Funktion zugeordnet ist (falls im Firebase-Projekt aktiviert).

Diese Funktionen funktionieren in jeder Hinsicht wie benutzerdefinierte Stringparameter, mit der Ausnahme, dass ihre Werte bei der Bereitstellung nie angefordert oder in .env-Dateien gespeichert werden, da ihre Werte immer der Firebase CLI bekannt sind.

Secret-Parameter

Parameter vom Typ Secret, die mit defineSecret() definiert werden, stellen Stringparameter mit einem in Cloud Secret Manager gespeicherten Wert dar. Anstatt eine Prüfung auf eine lokale .env-Datei durchzuführen und einen neuen Wert in die Datei zu schreiben, wenn sie fehlen, prüfen Secret-Parameter das Vorhandensein in Cloud Secret Manager und fordern während der Bereitstellung interaktiv den Wert eines neuen Secrets an.

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

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 Secrets bis zur Ausführung der Funktion ausgeblendet sind, können Sie sie beim Konfigurieren der 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 Ihre Anwendungslaufzeit. Nach der Bereitstellung können die Umgebungsvariablen über die Schnittstelle process.env 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 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 die 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}`);
});

Mehrere Gruppen von Umgebungsvariablen bereitstellen

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

Ein Projekt könnte beispielsweise diese drei Dateien mit geringfügig unterschiedlichen Werten für Entwicklung und Produktion enthalten:

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

ZIELGRUPPE=Menschen

ZIELGRUPPE=Entwickler*innen ZIELGRUPPE=Produktmenschen

Aufgrund der Werte in diesen separaten Dateien variiert der Satz der Umgebungsvariablen, die mit den Funktionen bereitgestellt werden, 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 Schlüssel für Umgebungsvariablen sind für die interne Verwendung reserviert. Verwenden Sie in Ihren .env-Dateien keinen der folgenden Schlüssel:

  • Alle Schlüssel, die mit X_GOOGLE_ beginnen
  • Alle Schlüssel, die EXT_ beginnen
  • Alle Schlüssel, die mit FIREBASE_ beginnen
  • Alle 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 zur Funktionskonfiguration verwendet werden. Sie sollten jedoch nicht als sichere Methode zum Speichern vertraulicher Informationen wie Datenbankanmeldedaten oder API-Schlüssel betrachtet werden. Das ist besonders wichtig, wenn Sie Ihre .env-Dateien in die Versionsverwaltung einchecken.

Zum Speichern vertraulicher Konfigurationsinformationen lässt sich Cloud Functions for Firebase in Secret Manager von Google Cloud einbinden. Dieser verschlüsselte Dienst speichert Konfigurationswerte sicher und ermöglicht bei Bedarf gleichzeitig einfachen Zugriff über die 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. Prüfen Sie vor der Bereitstellung, ob der Funktionscode den Zugriff auf das Secret mit dem 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. Stellen Sie Cloud Functions bereit:

    firebase deploy --only functions

Jetzt können Sie wie auf jede andere Umgebungsvariablen zugreifen. Wenn dagegen eine andere Funktion, die das Secret in runWith nicht angibt, versucht, auf das Secret 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 wurde, hat sie Zugriff auf den Secret-Wert. Nur Funktionen, die im Parameter runWith ein Secret enthalten, haben als Umgebungsvariable Zugriff auf dieses Secret. So können Sie dafür sorgen, dass Secret-Werte nur dort verfügbar sind, wo sie benötigt werden. Dadurch wird das Risiko verringert, dass ein Secret versehentlich offengelegt wird.

Secrets verwalten

Verwenden Sie die Firebase CLI, um Ihre Secrets zu verwalten. Beachten Sie bei der Verwaltung von Secrets auf diese Weise, dass Sie bei einigen Änderungen an der Befehlszeile die zugehörigen Funktionen ändern und/oder neu bereitstellen müssen. Insbesondere:

  • Wenn Sie einen neuen Wert für ein Secret festlegen, müssen Sie alle Funktionen, die auf dieses Secret verweisen, noch einmal bereitstellen, damit der neueste Wert abgerufen wird.
  • Achten Sie beim Löschen eines Secrets darauf, dass keine der bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten Secret-Wert verwenden, schlagen automatisch fehl.

Im Folgenden finden Sie eine Zusammenfassung der Firebase CLI-Befehle 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 zur Verwaltung einer bestimmten Version angeben. Beispiel:

functions:secrets:access SECRET_NAME[@VERSION]

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

So werden Secrets abgerechnet

Mit Secret Manager sind sechs aktive versions kostenlos verfügbar. Das bedeutet, dass Sie pro Monat sechs Secrets in einem Firebase-Projekt kostenlos haben können.

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

Secret Manager ermöglicht 10.000 nicht abgerechnete monatliche Zugriffsvorgänge auf ein Secret. Funktionsinstanzen lesen bei jedem Kaltstart nur die im Parameter runWith angegebenen Secrets. Wenn viele Funktionsinstanzen viele Secrets lesen, kann Ihr Projekt dieses Kontingent überschreiten. Dann 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 darauf ausgelegt, mit einem lokalen Cloud Functions-Emulator zusammenzuarbeiten.

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 Datei .env.

Ein Projekt könnte beispielsweise diese drei Dateien mit geringfügig unterschiedlichen Werten für die Entwicklung und für lokale Tests enthalten:

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

ZIELGRUPPE=Menschen

ZIELGRUPPE=Entwickler*innen AUDIENCE=Lokale Menschen

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

  $ 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 möglicherweise nicht auf Secret-Werte zugreifen.

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

Von Umgebungskonfiguration migrieren

Wenn Sie die Umgebungskonfiguration mit functions.config verwendet haben, können Sie die vorhandene Konfiguration als Umgebungsvariablen (im dotenv-Format) migrieren. Die Firebase CLI bietet einen Exportbefehl, der die Konfiguration jedes Alias oder Projekts, das in der Datei .firebaserc des Verzeichnisses aufgeführt ist, (im folgenden Beispiel local, dev und prod) als .env-Dateien ausgibt.

Exportieren Sie für die Migration die vorhandenen Umgebungskonfigurationen mit dem Befehl 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 Schlüssel für Umgebungsvariablen umzubenennen. Dies liegt daran, dass nicht alle Konfigurationen automatisch umgewandelt werden können, da sie möglicherweise ungültig oder ein reservierter Umgebungsvariablenschlüssel sein könnten.

Wir empfehlen, den Inhalt der generierten .env-Dateien sorgfältig zu prüfen, bevor Sie die Funktionen bereitstellen, oder die .env-Dateien in die Versionsverwaltung einchecken. Wenn Werte vertraulich sind und nicht gehackt werden sollen, entfernen Sie sie aus Ihren .env-Dateien und speichern Sie sie stattdessen an einem sicheren Ort in Secret Manager.

Außerdem müssen Sie den Funktionscode aktualisieren. Alle Funktionen, die functions.config verwenden, müssen jetzt stattdessen process.env verwenden, wie unter Auf 2. Generation upgraden beschrieben.

Umgebungskonfiguration

Bevor die Unterstützung für 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 alle neuen Projekte stattdessen Umgebungsvariablen verwenden, da diese einfacher zu verwenden sind und die Portabilität Ihres Codes verbessern.

Umgebungskonfiguration mit der Befehlszeile festlegen

Zum Speichern von Umgebungsdaten können Sie den Befehl firebase functions:config:set in der Firebase CLI verwenden. Jeder Schlüssel kann mithilfe von Punkten zum Gruppieren verwandter Konfigurationen mit einem Namespace versehen werden. In Schlüsseln sind nur Kleinbuchstaben zulässig, Großbuchstaben nicht.

Um beispielsweise die Client-ID und den API-Schlüssel für einen Dienst zu speichern, 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-Datei wird in etwa so ausgegeben:

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

Diese Funktion basiert auf der Google Cloud Runtime Configuration API.

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

Ein Teil der Konfiguration wird automatisch unter dem reservierten firebase-Namespace bereitgestellt. Die Umgebungskonfiguration wird in der ausgeführten Funktion über functions.config() zur Verfügung gestellt. Wenn Sie die obige Konfiguration verwenden möchten, könnte Ihr Code wie folgt 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}
  });
});

Umgebungskonfiguration zum Initialisieren eines Moduls verwenden

Einige Node-Module sind ohne Konfiguration bereit. Andere Module benötigen für die korrekte Initialisierung zusätzliche Konfiguration. Wir empfehlen, diese Konfiguration in Umgebungsvariablen zu speichern, anstatt sie hartzucodieren. Auf diese Weise können Sie Ihren Code viel portabler halten, sodass Sie Ihre Anwendung als Open Source zur Verfügung stellen oder einfach zwischen Produktions- und Staging-Versionen wechseln können.

Zur Verwendung des Moduls Slack Node SDK könnten Sie beispielsweise 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 Konfigurationsvariable slack.url für die Umgebung 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 in der Funktionslaufzeit und in lokal emulierten Funktionen automatisch eingefügt werden. Dazu gehören von Google Cloud ausgefüllte Felder sowie eine Firebase-spezifische Umgebungsvariablen:

process.env.FIREBASE_CONFIG: stellt die folgenden Konfigurationsinformationen für Firebase-Projekte 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, müssen Sie diese folgendermaßen initialisieren:

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

Wenn Sie Funktionen in TypeScript schreiben, initialisieren Sie diese 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 unter Verwendung von Dienstkonto-Anmeldedaten initialisieren müssen, können Sie die Anmeldedaten aus einer Datei laden und sie so 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);