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.

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!')

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.

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 während des globalen Bereichs zu einem Bereitstellungsfehler führt. Verwenden Sie den Initialisierungs-Callback onInit(), wenn Sie einen Parameter zum Initialisieren eines globalen Werts verwenden möchten. Dieser Callback wird vor der Ausführung von Funktionen in der Produktion ausgeführt, wird aber 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());
  })

Wenn Sie Parameter vom Typ Secret verwenden, müssen Sie beachten, dass sie nur in Verbindung mit Funktionen verfügbar sind, 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.

Die Python-Unterstützung für einen Initialisierungs-Callback ist bald verfügbar.

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: 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 von Parameterwerten und unterstützt auch Secrets von Cloud Secret Manager. Unterstützte Typen sind:

• Secret
• String
• Boolesch
• Ganzzahl
• Gleitkommazahl
• Liste (Node.js)

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 { 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 ermitteln, welche Option Sie auswählen sollen, 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 über die 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 aus dem Teilpaket firebase-functions/params verfügbar sind:

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 { 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 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 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 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 der 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 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:

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:

   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. 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:

   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 `runWith` parameter 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 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:

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 in Umgebungsvariablen gezeigt.