Konfigurierung Ihrer Umgebung

2. Generation 1. Generation

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.

Hinweis: Die Umgebungskonfiguration mit functions.config wurde in Version 6.0.0 eingestellt und wird in der nächsten Hauptversion nicht mehr unterstützt. Wenn Sie functions.config verwenden, sollten Sie dringend auf Umgebungsvariablen umstellen.

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 namens .env.<project_ID> im functions/-Verzeichnis 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

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 überprüft, bevor die Parameter echte Werte haben. Das Abrufen von Parameterwerten im globalen Gültigkeitsbereich führt also zu einem Bereitstellungsfehler. 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());
  })

Befehlszeilenverhalten konfigurieren

Parameter können mit einem Options-Objekt konfiguriert werden, das steuert, wie die Befehlszeile nach Werten fragt. 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. Unterstützte Typen sind:

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

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 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 während der Laufzeit verwendet werden, kann über die Funktion value 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 (falls 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.

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 Geheimnissen bis zur Ausführung der Funktion ausgeblendet sind, können Sie sie nicht bei der Konfiguration der Funktion verwenden.

Hinweis: Da der Functions-Emulator alle Funktionen für eine Codebasis in einem einzigen Prozess ausführt, werden derzeit immer Secrets in den Prozess eingefügt und Secret-Bindungen werden nicht berücksichtigt.

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-Schnittstelle 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. 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 einen alternativen Satz von Umgebungsvariablen für Ihre Firebase-Projekte benötigen (z. B. Staging oder Produktion), erstellen Sie eine .env.<project or alias>-Datei und schreiben Sie Ihre projektspezifischen Umgebungsvariablen dort. 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=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 keinen dieser 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
• Beliebiger Schlüssel aus der folgenden Liste:
• CLOUD_RUNTIME_CONFIG
• ENTRY_POINT
• GCP_PROJECT
• GCLOUD_PROJECT
• GOOGLE_CLOUD_PROJECT
• FUNCTION_TRIGGER_TYPE
• FUNKTIONSNAME
• FUNCTION_MEMORY_MB
• FUNCTION_TIMEOUT_SEC
• FUNCTION_IDENTITY
• FUNCTION_REGION
• 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 die Versionsverwaltung einchecken.

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.

Hinweis: Secret Manager ist ein kostenpflichtiger Dienst mit einer kostenlosen Stufe. Weitere Informationen finden Sie unter Abrechnung von Secrets.

Secret erstellen und verwenden

Verwenden Sie zum Erstellen eines Secrets die Firebase-Befehlszeile.

Hinweis: Verwenden Sie für Ihre Secrets keine reservierten Namen von Umgebungsvariablen.

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. Stellen Sie Cloud Functions bereit:

   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 eines versehentlichen Datenlecks reduzieren.

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.
• 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 den optionalen Versionsparameter angeben, um eine bestimmte Version zu verwalten. Beispiel:

functions:secrets:access SECRET_NAME[@VERSION]

Für weitere Informationen zu diesen Vorgängen übergeben Sie -h mit dem Befehl, um die Hilfe zur Befehlszeile 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-Befehlszeile, nicht verwendete Secret-Versionen 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 für ein Secret. 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.

Emulator-Unterstü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=Entwicklermenschen	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 Produktionssecrets 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 Unterstützung des Cloud Functions-Emulators für Umgebungsvariablen können Sie Secrets-Werte ü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, der die Konfiguration jedes Alias oder Projekts, das in der Datei .firebaserc Ihres Verzeichnisses aufgeführt ist (im Beispiel unten 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

In einigen Fällen werden Sie aufgefordert, ein Präfix einzugeben, um die exportierten Umgebungsvariablenschlüssel umzubenennen. Dies liegt daran, dass nicht alle Konfigurationen automatisch transformiert werden können, da sie entweder ungültig oder ein reservierter Schlüssel für Umgebungsvariablen sein 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 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

Warnung: Die Umgebungskonfiguration mit functions.config wurde in Version 6.0.0 eingestellt und wird in der nächsten Hauptversion nicht mehr für Funktionen der 1. Generation unterstützt. Die Unterstützung für die 2. Generation wurde nie eingeführt. Die Informationen in diesem Abschnitt richten sich an bestehende Nutzer, denen dringend empfohlen wird, zu Umgebungsvariablen zu migrieren.

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 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"

Nachdem Sie „functions:config:set“ ausgeführt haben, müssen Sie die Funktionen neu bereitstellen, damit die neue Konfiguration verfügbar ist.

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.

Mit functions.config auf die Umgebungskonfiguration in einer Funktion zugreifen

Einige Konfigurationen werden automatisch im reservierten Namespace firebase bereitgestellt. 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 Umgebungsvariablen zu speichern, anstatt sie hartzucodieren. Dadurch können Sie Ihren Code wesentlich portierbarer halten, sodass Sie Ihre Anwendung als Open Source verfügbar machen oder einfach zwischen Produktions- und Staging-Version wechseln können.

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

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 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://databaseName.firebaseio.com',
  storageBucket: 'projectId.appspot.com',
  projectId: 'projectId'
}

Diese Konfiguration wird automatisch angewendet, wenn Sie das Firebase Admin SDK ohne Argumente initialisieren. Wenn Sie Funktionen in JavaScript schreiben, initialisieren Sie sie 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);