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 Sie diese Art von Daten für Ihr Projekt einfach speichern und abrufen können.

Sie können zwischen diesen Optionen wählen:

• Parametrisierte Konfiguration (für die meisten Szenarien empfohlen). Dies ermöglicht eine stark typisierte Umgebungskonfiguration mit Parametern, die bei der Bereitstellung validiert werden. Dadurch werden Fehler vermieden und das Debugging vereinfacht.
• Dateibasierte Konfiguration von Umgebungsvariablen. Bei diesem Ansatz erstellen Sie manuell eine dotenv-Datei, um Umgebungsvariablen zu laden.

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

Parametrisierte Konfiguration

Cloud Functions for Firebase bietet eine Schnittstelle, über die Sie Konfigurationsparameter deklarativ in Ihrer Codebasis definieren können. 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 die Bereitstellung blockiert, 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 Befehlszeile während der Bereitstellung zur Eingabe der Werte aufgefordert. Die Werte werden dann automatisch in einer .env-Datei mit dem Namen .env.<project_ID> in Ihrem 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

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

Parameter im globalen Bereich verwenden

Während der Bereitstellung wird der Funktionscode geladen und geprüft, bevor die Parameter tatsächliche Werte haben. Das bedeutet, dass das Abrufen von Parameterwerten im globalen Bereich zu einem Bereitstellungsfehler führt. Wenn Sie einen Parameter zum Initialisieren eines globalen Werts verwenden möchten, verwenden Sie den Initialisierungs-Callback onInit(). Dieser Callback wird ausgeführt, bevor Funktionen in der Produktion ausgeführt werden. Er wird jedoch nicht während der Bereitstellung aufgerufen. 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/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, beachten Sie, dass diese nur im Prozess von Funktionen verfügbar sind, die das Secret gebunden haben. Wenn ein Secret nur in einigen Funktionen gebunden ist, prüfen Sie vor der Verwendung, ob secret.value() falsch ist.

CLI-Verhalten 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 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. Unterstützte Typen:

• Secret
• String
• Boolesch
• Ganzzahl
• Float
• Auflisten (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 der Funktion aus. Aufgrund dieser dualen Umgebungen ist beim Vergleichen von Parameterwerten und beim Festlegen von Laufzeitoptionen für Ihre Funktionen besondere Vorsicht geboten.

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 zu wissen, welche Option Sie auswählen müssen, müssen Sie integrierte Komparatoren 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 entsprechenden value-Funktion 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 im Unterpaket firebase-functions/params verfügbar sind:

Diese funktionieren in jeder Hinsicht wie benutzerdefinierte Stringparameter, mit der Ausnahme, dass ihre Werte der Firebase CLI immer bekannt sind. Daher werden ihre Werte bei der Bereitstellung nie abgefragt und auch nicht in .env-Dateien gespeichert.

Secret-Parameter

Parameter vom Typ Secret, die mit defineSecret() definiert werden, sind Stringparameter, deren Wert in Cloud Secret Manager gespeichert ist. Anstatt eine lokale .env-Datei zu prüfen und einen neuen Wert in die Datei zu schreiben, wenn er fehlt, prüfen Secret-Parameter, ob sie in Cloud Secret Manager vorhanden sind, und fragen während der Bereitstellung interaktiv nach dem Wert eines neuen Secrets.

Secret-Parameter müssen an einzelne Funktionen gebunden sein, 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 bis zur Ausführung der Funktion ausgeblendet sind, können Sie sie nicht während der Konfiguration Ihrer Funktion verwenden.

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. Mit diesem Ansatz können Sie Ihre Konfiguration organisieren und die kostenlose Stufe von Cloud Secret Manager effizienter nutzen, indem Sie eine Gruppe zusammengehöriger 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
    // ...
  }
);

Wenn Sie das Secret SOMEAPI_CONFIG erstellen möchten, legen Sie seinen Wert in Secret Manager auf einen JSON-String wie den folgenden fest:

{
  "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 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 (in Node.js-basierten Projekten) oder os.environ (in Python-basierten Projekten) gelesen werden.

Wenn Sie Ihre Umgebung so konfigurieren möchten, erstellen Sie in Ihrem Projekt eine .env-Datei, fügen Sie die gewünschten Variablen hinzu und stellen Sie sie 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 die 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 sind, 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 für Ihre Firebase-Projekte einen alternativen Satz von Umgebungsvariablen benötigen (z. B. Staging- und Produktionsumgebung), erstellen Sie eine .env.<project or alias>-Datei und schreiben Sie Ihre projektspezifischen Umgebungsvariablen dort hinein. Die Umgebungsvariablen aus den Dateien .env und den projektspezifischen .env-Dateien (falls vorhanden) werden in alle bereitgestellten Funktionen einbezogen.

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

Aufgrund der Werte in diesen separaten Dateien variiert die Gruppe der 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 keinen 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
• 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 sollten sie jedoch nicht als sichere Methode zum Speichern sensibler Informationen wie Datenbankanmeldedaten oder API-Schlüssel betrachten. Das ist besonders wichtig, wenn Sie Ihre .env-Dateien in die Versionsverwaltung einchecken.

Damit Sie vertrauliche Konfigurationsinformationen speichern können, ist Cloud Functions for Firebase in Google Cloud Secret Manager eingebunden. Dieser verschlüsselte Dienst speichert Konfigurationswerte sicher und ermöglicht gleichzeitig bei Bedarf einen einfachen Zugriff über Ihre Funktionen.

Secret erstellen und verwenden

Verwenden Sie zum Erstellen eines Secrets die Firebase-Befehlszeile.

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 weist darauf hin, dass Sie Funktionen bereitstellen müssen, damit die Änderung wirksam wird.

3. Prüfen Sie vor der Bereitstellung, ob der Funktionscode der Funktion den Zugriff auf das Secret mit der 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

   Sie können jetzt wie auf jede andere Umgebungsvariable darauf zugreifen. Wenn umgekehrt eine andere Funktion, die das Secret nicht angibt, versucht, auf das Secret zuzugreifen, erhält sie einen undefinierten 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 ist, hat sie Zugriff auf den Secret-Wert. Nur Funktionen, die ein Secret ausdrücklich in ihrer secrets-Option 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. Dadurch wird das Risiko verringert, dass ein Secret versehentlich preisgegeben wird.

Secrets verwalten

Verwenden Sie das Firebase CLI, um Ihre Secrets zu verwalten. Wenn Sie Secrets auf diese Weise verwalten, beachten Sie, dass bei einigen CLI-Änderungen die zugehörigen Funktionen geändert und/oder neu bereitgestellt werden müssen. Zum Beispiel:

• Wenn Sie einen neuen Wert für ein Secret festlegen, müssen Sie alle Funktionen, die auf dieses Secret verweisen, noch einmal bereitstellen, damit sie den neuesten Wert übernehmen.
• Wenn Sie ein Secret löschen, achten Sie darauf, dass keine Ihrer bereitgestellten Funktionen auf dieses Secret verweist. Funktionen, die einen gelöschten Secret-Wert verwenden, schlagen ohne Rückmeldung 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 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 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 haben können.

Standardmäßig versucht die Firebase-Befehlszeile, nicht verwendete Secret-Versionen automatisch zu löschen, wenn dies sinnvoll ist, 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 unberechnete monatliche Zugriffe auf ein Secret. Funktionsinstanzen lesen bei jedem Kaltstart nur die Secrets, die in der Option secrets angegeben sind. Wenn Sie viele Funktionsinstanzen haben, die viele Secrets lesen, überschreitet Ihr Projekt möglicherweise dieses Kontingent. In diesem Fall 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 für die Interaktion 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 diese drei Dateien mit leicht unterschiedlichen Werten für die Entwicklung und lokale Tests enthalten:

Wenn der Emulator im lokalen Kontext gestartet wird, lädt er die Umgebungsvariablen wie 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 möglicherweise nicht auf Secret-Werte zugreifen.

Ähnlich wie bei der Unterstützung von Umgebungsvariablen im Cloud Functions-Emulator können Sie Secret-Werte überschreiben, indem Sie eine .secret.local-Datei einrichten. So können Sie Ihre Funktionen lokal testen, insbesondere wenn Sie keinen Zugriff auf den Secret-Wert haben.

Von der Laufzeitkonfiguration migrieren

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

Migrieren Sie Ihre Konfiguration mit der Firebase-Befehlszeile zu Cloud Secret Manager, um Bereitstellungsfehler zu vermeiden. Dies wird dringend empfohlen, da es die effizienteste und sicherste Methode zur Migration Ihrer Konfiguration ist.

1. Konfiguration mit der Firebase-Befehlszeile 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 Ihrer Funktionsquelle. 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 die aktualisierten Funktionen bereit, um die Änderungen zu übernehmen und die Secret-Berechtigungen zu binden.

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

Automatisch ausgefüllte Umgebungsvariablen

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

process.env.FIREBASE_CONFIG: Liefert die folgenden Konfigurationsinformationen für das Firebase-Projekt:

{
  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 Ressourcen, die Sie in Ihrem Projekt bereitgestellt haben, variieren.

Diese Konfiguration wird automatisch angewendet, wenn Sie das Firebase Admin SDK ohne Argumente initialisieren. Wenn Sie Funktionen in JavaScript schreiben, initialisieren 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 Dienstkonto-Anmeldedaten initialisieren müssen, können Sie die Anmeldedaten aus einer Datei laden und 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);