Konfigurierung Ihrer Umgebung

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

Sie haben die folgenden Optionen:

• Parametrisierte Konfiguration (für die meisten Szenarien empfohlen) Diese Option bietet eine stark typisierte Umgebungskonfiguration mit Parametern, die bei der Bereitstellung validiert werden. So lassen sich Fehler vermeiden und die Fehlersuche vereinfachen.
• Dateibasierte Konfiguration von Umgebungsvariablen Bei dieser Methode erstellen Sie manuell eine dotenv-Datei zum Laden von Umgebungsvariablen.

Für die meisten Anwendungsfälle wird die parametrisierte Konfiguration empfohlen. Bei dieser Methode sind Konfigurationswerte sowohl zur Laufzeit als auch zur Bereitstellungszeit verfügbar. Die Bereitstellung wird blockiert, wenn nicht alle Parameter einen gültigen Wert haben. Im Gegensatz dazu ist die Konfiguration mit Umgebungsvariablen zur Bereitstellungszeit nicht verfügbar.

Parametrisierte Konfiguration

Cloud Functions for Firebase bietet eine Schnittstelle zum deklarativen Definieren von Konfigurations parametern in Ihrem Code. Der Wert dieser Parameter ist sowohl bei der Funktionsbereitstellung, beim Festlegen von Bereitstellungs- und Laufzeitoptionen als auch während der Ausführung verfügbar. Das bedeutet, dass die Bereitstellung über die CLI blockiert wird, wenn nicht alle Parameter einen gültigen Wert haben.

const { onRequest } = require('firebase-functions/v2/https');
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 = onRequest(
  { minInstances: minInstancesConfig },
(req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")
WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")

# To use configured parameters inside the config for a function, provide them
# directly. To use them at runtime, call .value() on them.
@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    return https_fn.Response(f'{WELCOME_MESSAGE.value()}! I am a function!')

Wenn Sie eine Funktion mit parametrisierten Konfigurationsvariablen bereitstellen, 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, werden Sie von der CLI während der Bereitstellung aufgefordert, die Werte anzugeben. Anschließend werden die Werte 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 Datei .env.<project_ID> in die Versionsverwaltung aufzunehmen.

Parameter im globalen Gültigkeitsbereich verwenden

Während der Bereitstellung wird der Code Ihrer Funktionen geladen und geprüft, bevor Ihre Parameter tatsächliche Werte haben. Wenn Sie Parameterwerte im globalen Gültigkeitsbereich abrufen, schlägt die Bereitstellung fehl. 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 er 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/v2/core');

const apiKey = defineSecret('GOOGLE_API_KEY');

let genAI;
onInit(() => {
  genAI = new GoogleGenerativeAI(apiKey.value());
})

from firebase_functions.core import init
from firebase_functions.params import StringParam, PROJECT_ID
import firebase_admin
import vertexai

location = StringParam("LOCATION")

x = "hello"

@init
def initialize():
  # Note: to write back to a global, you'll need to use the "global" keyword
  # to avoid creating a new local with the same name.
  global x
  x = "world"
  firebase_admin.initialize_app()
  vertexai.init(PROJECT_ID.value, location.value)

Wenn Sie Parameter vom Typ Secret verwenden, sind diese nur im Prozess von Funktionen verfügbar, die das Secret gebunden haben. Wenn ein Secret nur in einigen Funktionen gebunden ist, prüfen Sie, ob secret.value() falsch ist, bevor Sie es verwenden.

CLI-Verhalten konfigurieren

Parameter können mit einem Options-Objekt konfiguriert werden, das steuert, wie die CLI 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 zu fü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: params.select(["odd", "even"])});

const memory = defineInt("MEMORY", {
  description: "How much memory do you need?",
  input: params.select({ "micro": 256, "chonky": 2048 }),
});

const extensions = defineList("EXTENSIONS", {
  description: "Which file types should be processed?",
  input: params.multiSelect(["jpg", "tiff", "png", "webp"]),
});

const storageBucket = defineString('BUCKET', {
  description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets",
  input: params.PICK_STORAGE_BUCKET,
});

from firebase_functions.params import (
    StringParam,
    ListParam,
    TextInput,
    SelectInput,
    SelectOptions,
    ResourceInput,
    ResourceType,
)

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")

WELCOME_MESSAGE = StringParam(
    "WELCOME_MESSAGE",
    default="Hello World",
    description="The greeting that is returned to the caller of this function",
)

ONLY_PHONE_NUMBERS = StringParam(
    "PHONE_NUMBER",
    input=TextInput(
        validation_regex="\d{3}-\d{3}-\d{4}",
        validation_error_message="Please enter a phone number in the format XXX-YYY-XXX",
    ),
)

SELECT_OPTION = StringParam(
    "PARITY",
    input=SelectInput([SelectOptions(value="odd"), SelectOptions(value="even")]),
)

STORAGE_BUCKET = StringParam(
    "BUCKET",
    input=ResourceInput(type=ResourceType.STORAGE_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 für Parameterwerte und unterstützt auch Secrets aus Cloud Secret Manager. Folgende Typen werden unterstützt:

• Secret
• String
• Boolesch
• Ganzzahl
• Float
• Liste (Node.js)
• JSON-Secret (Node.js)

Informationen zu den Funktionen zum Definieren von Parametern finden Sie in der Referenz zum Namespace params.

Parameterwerte und -ausdrücke

Firebase wertet Ihre Parameter sowohl bei der Bereitstellung als auch während der Ausführung Ihrer Funktion aus. Aufgrund dieser beiden Umgebungen ist besondere Vorsicht geboten, wenn Sie Parameterwerte vergleichen und sie verwenden, um Laufzeitoptionen für Ihre Funktionen festzulegen.

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

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

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

from firebase_functions import https_fn
from firebase_functions.params import IntParam

MIN_INSTANCES = IntParam("HELLO_WORLD_MIN_INSTANCES")

@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    ...

Wenn Sie außerdem einen Vergleich mit einem Parameter durchführen müssen, um die richtige Option auszuwählen, müssen Sie integrierte Vergleichsoperatoren verwenden, anstatt den Wert zu prüfen:

const { onRequest } = require('firebase-functions/v2/https');
const environment = params.defineString(‘ENVIRONMENT’, {default: 'dev'});

// use built-in comparators
const minInstancesConfig = environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = onRequest(
  { minInstances: minInstancesConfig },
  (req, res) => {
    //…

from firebase_functions import https_fn
from firebase_functions.params import IntParam, StringParam

ENVIRONMENT = StringParam("ENVIRONMENT", default="dev")
MIN_INSTANCES = ENVIRONMENT.equals("PRODUCTION").then(10, 0)

@https_fn.on_request(min_instances=MIN_INSTANCES)
def hello_world(req):
    ...

Auf Parameter und Parameterausdrücke, die nur zur Laufzeit verwendet werden, kann mit der Funktion value zugegriffen werden:

const { onRequest } = require('firebase-functions/v2/https');
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 = onRequest(
(req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

from firebase_functions import https_fn
from firebase_functions.params import StringParam

WELCOME_MESSAGE = StringParam("WELCOME_MESSAGE")

@https_fn.on_request()
def hello_world(req):
    return https_fn.Response(f'{WELCOME_MESSAGE.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:

Diese Funktion ähnelt in jeder Hinsicht benutzerdefinierten Stringparametern. Da ihre Werte jedoch der Firebase CLI immer bekannt sind, werden Sie bei der Bereitstellung nicht aufgefordert, die Werte anzugeben, und sie werden auch nicht in .env-Dateien gespeichert.

Secret-Parameter

Parameter vom Typ Secret, die mit defineSecret() definiert werden, stellen String parameter dar, deren Wert in Cloud Secret Manager gespeichert ist. Anstatt eine lokale .env-Datei zu prüfen 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 werden Sie interaktiv aufgefordert, den Wert eines neuen Secrets anzugeben.

Secret-Parameter müssen an einzelne Funktionen gebunden werden, die Zugriff darauf haben sollen:

const { onRequest } = require('firebase-functions/v2/https');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');

export const postToDiscord = onRequest(
  { secrets: [discordApiKey] },
  (req, res) => {
  const apiKey = discordApiKey.value();
    //…

from firebase_functions import https_fn
from firebase_functions.params import SecretParam

DISCORD_API_KEY = SecretParam('DISCORD_API_KEY')

@https_fn.on_request(secrets=[DISCORD_API_KEY])
def post_to_discord(req):
    api_key = DISCORD_API_KEY.value

Da die Werte von Secrets erst bei der Ausführung der Funktion sichtbar sind, können Sie sie nicht verwenden, während Sie Ihre Funktion konfigurieren.

Strukturierte JSON-Secrets

Wenn Sie mehrere Konfigurationswerte haben, die logisch miteinander verknüpft sind (z. B. Einstellungen für einen Drittanbieterdienst), können Sie sie mit defineJsonSecret() als strukturiertes JSON-Objekt in einem einzigen Secret speichern. So können Sie Ihre Konfiguration besser organisieren und das kostenlose Kontingent von Cloud Secret Manager effizienter nutzen, indem Sie eine Gruppe verwandter Konfigurationswerte in einem einzigen Secret speichern.

Der in Secret Manager gespeicherte Wert muss ein gültiger JSON-String sein. Das SDK parst den JSON-String automatisch in ein JavaScript-Objekt, wenn Sie auf .value() zugreifen.

Beispiel :

const { onRequest } = require('firebase-functions/v2/https');
const { defineJsonSecret } = require('firebase-functions/params');

// Define a single secret to hold all configuration for some API
const someApiConfig = defineJsonSecret('SOMEAPI_CONFIG');

exports.myApi = onRequest(
  { secrets: [someApiConfig] },
  (req, res) => {
    // someApiConfig.value() automatically parses the JSON secret
    const { apiKey, webhookSecret, clientId } = someApiConfig.value();

    // Now you can use apiKey, webhookSecret, clientId
    // ...
  }
);

Um das Secret SOMEAPI_CONFIG zu erstellen, legen Sie seinen Wert in Secret Manager auf einen JSON-String fest, z. B.:

{
  "apiKey": "key_...",
  "webhookSecret": "secret_...",
  "clientId": "client_..."
}

Wenn der Secret-Wert kein gültiges JSON ist, wird beim Zugriff auf someApiConfig.value() zur Laufzeit ein Fehler ausgegeben.

Umgebungsvariablen

Cloud Functions for Firebase unterstützt das dotenv Dateiformat zum Laden von Umgebungsvariablen, die in einer .env Datei angegeben sind, in die Laufzeit Ihrer Anwendung. Nach der Bereitstellung können die Umgebungsvariablen über die process.env Schnittstelle (in Node.js-basierten Projekten) oder os.environ (in Python-basierten Projekten) 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 sie bereit:

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. Stellen Sie Funktionen bereit und prüfen Sie, ob die Umgebungsvariablen geladen wurden:

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

Sobald Ihre benutzerdefinierten Umgebungsvariablen bereitgestellt wurden, kann Ihr Funktionscode darauf zugreifen:

// Responds with "Hello Earth and Humans"
exports.hello = onRequest((request, response) => {
  response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});

import os

@https_fn.on_request()
def hello(req):
    return https_fn.Response(
        f"Hello {os.environ.get('PLANET')} and {os.environ.get('AUDIENCE')}"
    )

Mehrere Sätze von Umgebungsvariablen bereitstellen

Wenn Sie einen alternativen Satz von Umgebungsvariablen für Ihre Firebase Projekte benötigen (z. B. für die Staging- im Vergleich zur Produktionsumgebung), erstellen Sie eine .env.<project or alias> Datei und schreiben Sie dort Ihre projektspezifischen Umgebungsvariablen. Die Umgebungsvariablen aus .env und projektspezifischen .env-Dateien (falls vorhanden) sind in allen bereitgestellten Funktionen enthalten.

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

Angesichts der Werte in diesen separaten Dateien variiert der Satz von Umgebungsvariablen, die mit Ihren 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 Umgebungsvariablenschlüssel sind für die interne Verwendung reserviert. Verwenden Sie keine dieser Schlüssel in Ihren .env-Dateien:

• Alle Schlüssel, die mit X_GOOGLE_ beginnen
• Alle Schlüssel, die mit 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

Umgebungsvariablen, die in .env-Dateien gespeichert sind, können zur Funktionskonfiguration verwendet werden. Sie sollten sie jedoch nicht als sichere Methode zum Speichern vertraulicher Informationen wie Datenbankanmeldedaten oder API-Schlüssel betrachten. Das ist besonders wichtig, wenn Sie Ihre .env-Dateien in die Quellcodeverwaltung einchecken.

Um Ihnen beim Speichern vertraulicher Konfigurationsinformationen zu helfen, ist Cloud Functions for Firebase eingebunden in Google Cloud Secret Manager. Dieser verschlüsselte Dienst speichert Konfigurationswerte sicher und ermöglicht bei Bedarf einen 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 CLI gibt eine Erfolgsmeldung aus und warnt Sie, dass Sie Funktionen bereitstellen müssen, damit die Änderung wirksam wird.

3. Prüfen Sie vor der Bereitstellung, ob Ihr Funktionscode der Funktion den Zugriff auf das Secret über die Option secrets ermöglicht:

   Node.js

   const { onRequest } = require('firebase-functions/v2/https');
   
   exports.processPayment = onRequest(
     { secrets: ["SECRET_NAME"] },
     (req, res) => {
       const myBillingService = initializeBillingService(
         // reference the secret value
         process.env.SECRET_NAME
       );
       // Process the payment
     }
   );

   Python

   import os
   from firebase_functions import https_fn
   
   @https_fn.on_request(secrets=["SECRET_NAME"])
   def process_payment(req):
       myBillingService = initialize_billing(key=os.environ.get('SECRET_NAME'))
       # Process the payment
       ...
   

4. Cloud Functions bereitstellen:

   firebase deploy --only functions

   Jetzt können Sie wie bei jeder anderen Umgebungsvariable darauf zugreifen. Wenn eine andere Funktion, die das Secret nicht angibt, versucht, darauf zuzugreifen, erhält sie einen nicht definierten Wert:

   Node.js

   exports.anotherEndpoint = onRequest((request, response) => {
     response.send(`The secret API key is ${process.env.SECRET_NAME}`);
     // responds with "The secret API key is undefined" because the `secrets` option is missing
   });
   

   Python

   @https_fn.on_request()
   def another_endpoint(req):
       return https_fn.Response(f"The secret API key is {os.environ.get("SECRET_NAME")}")
       # Responds with "The secret API key is None" because the `secrets` parameter is missing.
   

Sobald Ihre Funktion bereitgestellt wurde, hat sie Zugriff auf den Secret-Wert. Nur Funktionen, die in ihrer Option secrets ein Secret angeben, haben Zugriff auf dieses Secret als Umgebungsvariable. So können Sie sicherstellen, dass Secret-Werte nur dort verfügbar sind, wo sie benötigt werden, und das Risiko einer versehentlichen Offenlegung eines Secrets verringern.

Secrets verwalten

Verwenden Sie die Firebase CLI, um Ihre Secrets zu verwalten. Beachten Sie, dass einige CLI-Änderungen erfordern, dass Sie zugehörige Funktionen ändern und/oder neu bereitstellen. 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 übernehmen.
• Wenn Sie ein Secret löschen, prüfen Sie, ob keine Ihrer bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten Secret-Wert verwenden, schlagen ohne Fehlermeldung fehl.

Hier 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

# Set secret from file
firebase functions:secrets:set SECRET_NAME --data-file file.json

# Validate secret value as json
cat file.json | firebase functions:secrets:set SECRET_NAME --format=json

# Pipe from stdin and set secret
cat file.json | firebase functions:secrets:set SECRET_NAME --format=json

# 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 Parameter `version` angeben, um eine bestimmte Version zu verwalten. Beispiel:

functions:secrets:access SECRET_NAME[@VERSION]

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

Abrechnung von Secrets

Secret Manager ermöglicht 6 aktive Secret Versionen kostenlos. Das bedeutet, dass Sie in einem Firebase-Projekt 6 Secrets pro Monat kostenlos verwenden 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 in Rechnung gestellte Zugriffe pro Monat auf ein Secret. Funktionsinstanzen lesen nur die Secrets, die in ihrer Option secrets angegeben sind, bei jedem Kaltstart. Wenn viele Funktionsinstanzen viele Secrets lesen, kann Ihr Projekt dieses Kontingent überschreiten. In diesem Fall werden Ihnen 0,03 $pro 10.000 Zugriffe in Rechnung gestellt.

Weitere Informationen finden Sie unter Secret Manager Preise.

Emulatorunterstützung

Die Umgebungskonfiguration mit dotenv ist für die Zusammenarbeit mit einem lokalen Cloud Functions Emulator konzipiert.

Wenn Sie einen lokalen Cloud Functions Emulator verwenden, können Sie Umgebung variablen 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 diese drei Dateien mit leicht unterschiedlichen Werten für die Entwicklung und lokale Tests enthalten:

Wenn der Emulator im lokalen Kontext gestartet wird, werden die Umgebungsvariablen wie folgt geladen:

  $ 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 standardmäßigen Anmeldedaten der Anwendung 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 bei der Cloud Functions Emulatorunterstützung für Umgebungsvariablen können Sie Secret-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 Secret-Wert haben.

Von der Laufzeitkonfiguration migrieren

Die functions.config-API ist veraltet und wird im März 2027 außer Betrieb genommen. Nach diesem Datum schlagen Bereitstellungen mit functions.config fehl.

Um Bereitstellungsfehler zu vermeiden, migrieren Sie Ihre Konfiguration mit der Firebase CLI zu Cloud Secret Manager. Dies ist die effizienteste und sicherste Methode zum Migrieren Ihrer Konfiguration.

1. Konfiguration mit der Firebase CLI exportieren

   Verwenden Sie den Befehl config export, um Ihre vorhandene Umgebungskonfiguration in ein neues Secret in Cloud Secret Manager zu exportieren:

   $ firebase functions:config:export
   i  This command retrieves your Runtime Config values (accessed via functions.config())
      and exports them as a Secret Manager secret.
   
   i  Fetching your existing functions.config() from your project...  ✔
      Fetched your existing functions.config().
   
   i  Configuration to be exported:
   ⚠  This may contain sensitive data. Do not share this output.
   
   {
      ...
   }
   
   ✔ What would you like to name the new secret for your configuration? RUNTIME_CONFIG
   
   ✔  Created new secret version projects/project/secrets/RUNTIME_CONFIG/versions/1```
   

2. Funktionscode aktualisieren, um Secrets zu binden

   Wenn Sie die im neuen Secret in Cloud Secret Manager gespeicherte Konfiguration verwenden möchten, verwenden Sie die defineJsonSecret-API in Ihrem Funktionsquellcode. Achten Sie außerdem darauf, dass Secrets an alle Funktionen gebunden sind, die sie benötigen.

   Vorher

   const functions = require("firebase-functions/v1");
   
   exports.myFunction = functions.https.onRequest((req, res) => {
     const apiKey = functions.config().someapi.key;
     // ...
   });
   

   Nachher

   const { onRequest } = require("firebase-functions/v2/https");
   const { defineJsonSecret } = require("firebase-functions/params");
   
   const config = defineJsonSecret("RUNTIME_CONFIG");
   
   exports.myFunction = onRequest(
     // Bind secret to your function
     { secrets: [config] },
     (req, res) => {
       // Access secret values via .value()
       const apiKey = config.value().someapi.key;
       // ...
   });
   

3. Funktionen bereitstellen

   Stellen Sie Ihre aktualisierten Funktionen bereit, um die Änderungen zu übernehmen und die Secret-Berechtigungen zu binden.

   firebase deploy --only functions:<your-function-name>
   

Automatisch eingefügte Umgebungsvariablen

Es gibt Umgebungsvariablen, die automatisch in der Funktionslaufzeit und in lokal emulierten Funktionen eingefügt werden. Dazu gehören die von Google Cloudeingefügten Variablen sowie eine Firebase-spezifische Umgebungsvariable:

process.env.FIREBASE_CONFIG: Enthält die folgenden Firebase-Projektkonfigurationsinformationen:

{
  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 mithilfe von Dienstkontoanmeldedaten 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);