Configurer votre environnement

Vous aurez souvent besoin d'une configuration supplémentaire pour vos fonctions, comme des clés API tierces ou des paramètres réglables. Le Firebase SDK pour Cloud Functions offre une configuration d'environnement intégrée qui facilite le stockage et la récupération de ce type de données pour votre projet.

Vous pouvez choisir parmi les options suivantes :

Configuration paramétrée (recommandée pour la plupart des scénarios). Elle fournit une configuration d'environnement fortement typée avec des paramètres validés au moment du déploiement, ce qui évite les erreurs et simplifie le débogage.
Configuration basée sur des fichiers de variables d'environnement. Avec cette approche, vous créez manuellement un fichier dotenv pour charger les variables d'environnement.

Pour la plupart des cas d'utilisation, la configuration paramétrée est recommandée. Cette approche rend les valeurs de configuration disponibles à la fois au moment de l'exécution et du déploiement, et le déploiement est bloqué, sauf si tous les paramètres ont une valeur valide. À l'inverse, la configuration avec des variables d'environnement n'est pas disponible au moment du déploiement.

Configuration paramétrée

Cloud Functions for Firebase fournit une interface permettant de définir des paramètres de configuration de manière déclarative dans votre code. La valeur de ces paramètres est disponible à la fois lors du déploiement de la fonction, lors de la définition des options de déploiement et d'exécution, et lors de l'exécution. Cela signifie que la CLI bloquera le déploiement, sauf si tous les paramètres ont une valeur valide.

Node.js

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.`);
  }
);

Python

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

Lors du déploiement d'une fonction avec des variables de configuration paramétrées, la CLI Firebase tente d'abord de charger leurs valeurs à partir de fichiers .env locaux. Si elles ne sont pas présentes dans ces fichiers et qu'aucune default n'est définie, la CLI vous invite à saisir les valeurs lors du déploiement, puis enregistre automatiquement leurs valeurs dans un .env nommé .env.<project_ID> dans votre répertoire functions/ :

$ 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

En fonction de votre workflow de développement, il peut être utile d'ajouter le fichier généré .env.<project_ID> au contrôle des versions.

Utiliser des paramètres dans le champ d'application global

Lors du déploiement, le code de vos fonctions est chargé et inspecté avant que vos paramètres n'aient des valeurs réelles. Cela signifie que la récupération des valeurs de paramètres dans le champ d'application global entraîne un échec du déploiement. Si vous souhaitez utiliser un paramètre pour initialiser une valeur globale, utilisez le rappel d'initialisation onInit(). Ce rappel s'exécute avant toute fonction en production, mais n'est pas appelé au moment du déploiement. Il s'agit donc d'un emplacement sûr pour accéder à la valeur d'un paramètre.

Node.js

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());
})

Python

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)

Si vous utilisez des paramètres de type Secret, notez qu'ils ne sont disponibles que dans le processus des fonctions qui ont lié le secret. Si un secret n'est lié que dans certaines fonctions, vérifiez si secret.value() est faux avant de l'utiliser.

Configurer le comportement de la CLI

Les paramètres peuvent être configurés avec un objet Options qui contrôle la façon dont la CLI vous invite à saisir des valeurs. L'exemple suivant définit des options pour valider le format d'un numéro de téléphone, fournir une option de sélection simple et renseigner automatiquement une option de sélection à partir du projet Firebase :

Node.js

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,
});

Python

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

Types de paramètres

La configuration paramétrée fournit un typage fort pour les valeurs de paramètres et prend également en charge les secrets de Cloud Secret Manager. Voici les types compatibles :

Secret
Chaîne
Booléen
Integer
Float
List (Node.js)
JSON Secret (Node.js)

Pour en savoir plus sur les fonctions permettant de définir des paramètres, consultez la référence de l'espace de noms params.

Valeurs et expressions de paramètres

Firebase évalue vos paramètres à la fois au moment du déploiement et lors de l'exécution de votre fonction. En raison de ces deux environnements, vous devez faire preuve d'une attention particulière lorsque vous comparez des valeurs de paramètres et lorsque vous les utilisez pour définir des options d'exécution pour vos fonctions.

Pour transmettre un paramètre à votre fonction en tant qu'option d'exécution, transmettez-le directement :

Node.js

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) => {
    //…

Python

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

De plus, si vous devez effectuer une comparaison avec un paramètre pour savoir quelle option choisir, vous devrez utiliser des comparateurs intégrés au lieu de vérifier la valeur :

Node.js

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) => {
    //…

Python

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

Les paramètres et les expressions de paramètres qui ne sont utilisés qu'au moment de l'exécution sont accessibles avec leur fonction value :

Node.js

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.`);
  }
);

Python

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

Paramètres intégrés

Le SDK Cloud Functions propose trois paramètres prédéfinis, disponibles à partir du sous-package firebase-functions/params :

Node.js

projectID : projet Cloud dans lequel la fonction s'exécute.
databaseURL : URL de l'instance Realtime Database associée à la fonction (si elle est activée dans le projet Firebase).
storageBucket : bucket Cloud Storage associé à la fonction (si elle est activée dans le projet Firebase).

Python

PROJECT_ID : projet Cloud dans lequel la fonction s'exécute.
DATABASE_URL : URL de l'instance Realtime Database associée à la fonction (si elle est activée dans le projet Firebase).
STORAGE_BUCKET : bucket Cloud Storage associé à la fonction (si elle est activée dans le projet Firebase).

Ces fonctions sont identiques aux paramètres de chaîne définis par l'utilisateur à tous égards, sauf que, comme leurs valeurs sont toujours connues de la CLI Firebase, elles ne seront jamais demandées lors du déploiement ni enregistrées dans des fichiers .env.

Paramètres secrets

Les paramètres de type Secret, définis à l'aide de defineSecret(), représentent des paramètres de chaîne dont la valeur est stockée dans Cloud Secret Manager. Au lieu de vérifier l'existence d'un fichier .env local et d'y écrire une nouvelle valeur si elle est manquante, les paramètres secrets vérifient l'existence dans Cloud Secret Manager et demandent de manière interactive la valeur d'un nouveau secret lors du déploiement.

Les paramètres secrets doivent être liés à des fonctions individuelles qui doivent y avoir accès :

Node.js

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();
    //…

Python

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

Comme les valeurs des secrets sont masquées jusqu'à l'exécution de la fonction, vous ne pouvez pas les utiliser lors de la configuration de votre fonction.

Secrets JSON structurés

Si vous disposez de plusieurs valeurs de configuration logiquement liées (par exemple, les paramètres d'un service tiers), vous pouvez les stocker ensemble en tant qu'objet JSON structuré dans un seul secret à l'aide de defineJsonSecret(). Cette approche peut vous aider à organiser votre configuration et à utiliser plus efficacement le niveau sans frais de Cloud Secret Manager en stockant un groupe de valeurs de configuration associées dans un seul secret.

La valeur stockée dans Secret Manager doit être une chaîne JSON valide. Le SDK analysera automatiquement la chaîne JSON en un objet JavaScript lorsque vous accéderez à .value().

Exemple :

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
    // ...
  }
);

Pour créer le secret SOMEAPI_CONFIG, vous devez définir sa valeur dans Secret Manager sur une chaîne JSON comme suit :

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

Si la valeur du secret n'est pas un code JSON valide, l'accès à someApiConfig.value() génère une erreur au moment de l'exécution.

Variables d'environnement

Cloud Functions for Firebase est compatible avec le format de fichier dotenv pour charger les variables d'environnement spécifiées dans un fichier .env dans l'environnement d'exécution de votre application. Une fois déployées, les variables d'environnement peuvent être lues via l' process.env interface (dans les projets basés sur Node.js) ou os.environ (dans les projets basés sur Python).

Pour configurer votre environnement de cette manière, créez un fichier .env dans votre projet, ajoutez les variables souhaitées et déployez-le :

Créez un fichier .env dans votre répertoire functions/ :

# Directory layout:
#   my-project/
#     firebase.json
#     functions/
#       .env
#       package.json
#       index.js

Ouvrez le fichier .env pour le modifier et ajoutez les clés souhaitées. Exemple :
```
PLANET=Earth
AUDIENCE=Humans
```

Déployez les fonctions et vérifiez que les variables d'environnement ont été chargées :

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

Une fois vos variables d'environnement personnalisées déployées, le code de votre fonction peut y accéder :

Node.js

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

Python

import os

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

Déployer plusieurs ensembles de variables d'environnement

Si vous avez besoin d'un autre ensemble de variables d'environnement pour vos projets Firebase (par exemple, pour la préproduction et la production), créez un .env.<project or alias> fichier et écrivez-y vos variables d'environnement spécifiques au projet. Les variables d'environnement des fichiers .env et .env spécifiques au projet (s'ils existent) seront incluses dans toutes les fonctions déployées.

Par exemple, un projet peut inclure ces trois fichiers contenant des valeurs légèrement différentes pour le développement et la production :

`.env`	`.env.dev`	`.env.prod`
PLANET=Earth AUDIENCE=Humans	AUDIENCE=Dev Humans	AUDIENCE=Prod Humans

Compte tenu des valeurs de ces fichiers distincts, l'ensemble des variables d'environnement déployées avec vos fonctions varie en fonction de votre projet cible :

$ 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

Variables d'environnement réservées

Certaines clés de variables d'environnement sont réservées à un usage interne. N'utilisez aucune de ces clés dans vos fichiers .env :

Toutes les clés commençant par X_GOOGLE_
Toutes les clés commençant par EXT_
Toutes les clés commençant par FIREBASE_
Toute clé de la liste suivante :
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

Stocker des informations de configuration sensibles et y accéder

Les variables d'environnement stockées dans des fichiers .env peuvent être utilisées pour la configuration des fonctions, mais vous ne devez pas les considérer comme un moyen sécurisé de stocker des informations sensibles telles que des identifiants de base de données ou des clés API. Cela est particulièrement important si vous enregistrez vos fichiers .env dans le contrôle des sources.

Pour vous aider à stocker des informations de configuration sensibles, Cloud Functions for Firebase s'intègre à Google Cloud Secret Manager. Ce service chiffré stocke les valeurs de configuration de manière sécurisée, tout en permettant un accès facile depuis vos fonctions si nécessaire.

Créer et utiliser un secret

Pour créer un secret, utilisez la Firebase CLI.

Pour créer et utiliser un secret :

À la racine de votre répertoire de projet local, exécutez la commande suivante :
```
firebase functions:secrets:set SECRET_NAME
```
Saisissez une valeur pour SECRET_NAME.

La CLI affiche un message de réussite et vous avertit que vous devez déployer des fonctions pour que la modification prenne effet.

Avant le déploiement, assurez-vous que le code de vos fonctions permet à la fonction d'accéder au secret à l'aide de l'option secrets :

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

Déployez Cloud Functions :

firebase deploy --only functions

Vous pourrez désormais y accéder comme à n'importe quelle autre variable d'environnement. À l'inverse, si une autre fonction qui ne spécifie pas le secret tente d'y accéder, elle reçoit une valeur non définie :

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.

Une fois votre fonction déployée, elle aura accès à la valeur du secret. Seules les fonctions qui incluent spécifiquement un secret dans leur option secrets y auront accès en tant que variable d'environnement. Cela vous permet de vous assurer que les valeurs secrètes ne sont disponibles que là où elles sont nécessaires, ce qui réduit le risque de fuite accidentelle d'un secret.

Gérer les secrets

Utilisez la CLI Firebase pour gérer vos secrets. Lorsque vous gérez des secrets de cette manière, n'oubliez pas que certaines modifications de la CLI nécessitent de modifier et/ou de redéployer les fonctions associées. Plus spécifiquement :

Chaque fois que vous définissez une nouvelle valeur pour un secret, vous devez redéployer toutes les fonctions qui font référence à ce secret pour qu'elles récupèrent la dernière valeur.
Si vous supprimez un secret, assurez-vous qu'aucune de vos fonctions déployées ne fait référence à ce secret. Les fonctions qui utilisent une valeur secrète qui a été supprimée échoueront en mode silencieux.

Voici un résumé des commandes de la CLI Firebase pour la gestion des secrets :

# 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

Pour les commandes access et destroy, vous pouvez fournir le paramètre de version facultatif pour gérer une version particulière. Exemple :

functions:secrets:access SECRET_NAME[@VERSION]

Pour en savoir plus sur ces opérations, transmettez -h avec la commande pour afficher l'aide de la CLI.

Facturation des secrets

Secret Manager autorise six versions de secrets actives sans frais. Cela signifie que vous pouvez avoir six secrets par mois dans un projet Firebase sans frais.

Par défaut, la Firebase CLI tente de détruire automatiquement les versions de secrets inutilisées, le cas échéant, par exemple lorsque vous déployez des fonctions avec une nouvelle version du secret. Vous pouvez également nettoyer activement les secrets inutilisés à l'aide de functions:secrets:destroy et functions:secrets:prune.

Secret Manager autorise 10 000 opérations d'accès mensuelles non facturées sur un secret. Les instances de fonction ne lisent que les secrets spécifiés dans leur option secrets à chaque démarrage à froid. Si vous avez de nombreuses instances de fonction qui lisent de nombreux secrets, votre projet peut dépasser cette limite.Vous serez alors facturé 0,03 $par tranche de 10 000 opérations d'accès.

Pour en savoir plus, consultez Secret Manager Tarifs.

Prise en charge des émulateurs

La configuration d'environnement avec dotenv est conçue pour interagir avec un émulateur Cloud Functionslocal.

Lorsque vous utilisez un émulateur Cloud Functions local, vous pouvez remplacer les variables d'environnement de votre projet en configurant un fichier .env.local. Le contenu de .env.local est prioritaire sur .env et sur le fichier .env spécifique au projet.

Par exemple, un projet peut inclure ces trois fichiers contenant des valeurs légèrement différentes pour le développement et les tests locaux :

`.env`	`.env.dev`	`.env.local`
PLANET=Earth AUDIENCE=Humans	AUDIENCE=Dev Humans	AUDIENCE=Local Humans

Lorsqu'il est démarré dans le contexte local, l'émulateur charge les variables d'environnement comme indiqué :

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

Secrets et identifiants dans l'émulateur Cloud Functions

L'émulateur Cloud Functions est compatible avec l'utilisation de secrets pour stocker des informations de configuration sensibles et y accéder. Par défaut, l'émulateur tente d'accéder à vos secrets de production à l'aide des identifiants par défaut de l'application. Dans certaines situations, comme les environnements d'intégration continue, l'émulateur peut ne pas pouvoir accéder aux valeurs secrètes en raison de restrictions d'autorisation.

Comme pour la prise en charge des variables d'environnement par l'émulateur Cloud Functions, vous pouvez remplacer les valeurs secrètes en configurant un fichier .secret.local. Cela vous permet de tester facilement vos fonctions localement, en particulier si vous n'avez pas accès à la valeur secrète.

Migrer à partir de la configuration d'exécution

L'API functions.config est obsolète et sera mise hors service en mars 2027. Après cette date, les déploiements avec functions.config échoueront.

Pour éviter les échecs de déploiement, migrez votre configuration vers Cloud Secret Manager à l'aide de la Firebase CLI. Cette méthode est fortement recommandée, car elle constitue le moyen le plus efficace et le plus sécurisé de migrer votre configuration.

Exporter la configuration avec la Firebase CLI

Utilisez la commande config export pour exporter votre configuration d'environnement existante vers un nouveau secret dans Cloud Secret Manager :

$ 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```

Mettre à jour le code de la fonction pour lier les secrets

Pour utiliser la configuration stockée dans le nouveau secret dans Cloud Secret Manager, utilisez l'API defineJsonSecret dans la source de votre fonction. Assurez-vous également que les secrets sont liés à toutes les fonctions qui en ont besoin.

Avant

const functions = require("firebase-functions/v1");

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

Après

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;
    // ...
});

Déployer des fonctions

Déployez vos fonctions mises à jour pour appliquer les modifications et lier les autorisations secrètes.
```
firebase deploy --only functions:<your-function-name>
```

Variables d'environnement renseignées automatiquement

Certaines variables d'environnement sont renseignées automatiquement dans l'environnement d'exécution des fonctions et dans les fonctions émulées localement. Il s'agit notamment de celles renseignées par Google Cloud, ainsi que d'une variable d'environnement spécifique à Firebase :

process.env.FIREBASE_CONFIG : fournit les informations de configuration du projet Firebase suivantes :

{
  databaseURL: 'https://DATABASE_NAME.firebaseio.com',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  projectId: 'PROJECT_ID'
}

Notez que les valeurs de votre configuration Firebase réelle peuvent varier en fonction des ressources que vous avez provisionnées dans votre projet.

Cette configuration est appliquée automatiquement lorsque vous initialisez le SDK Admin Firebase sans aucun argument. Si vous écrivez des fonctions en JavaScript, initialisez-les comme suit :

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

Si vous écrivez des fonctions en TypeScript, initialisez-les comme suit :

import * as functions from 'firebase-functions/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
admin.initializeApp();

Si vous devez initialiser le SDK Admin avec la configuration de projet par défaut à l'aide des identifiants de compte de service, vous pouvez charger les identifiants à partir d'un fichier et les ajouter à FIREBASE_CONFIG comme suit :

serviceAccount = require('./serviceAccount.json');

const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);

Configurer votre environnement Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Configuration paramétrée

Node.js

Python

Utiliser des paramètres dans le champ d'application global

Node.js

Python

Configurer le comportement de la CLI

Node.js

Python

Types de paramètres

Valeurs et expressions de paramètres

Node.js

Python

Node.js

Python

Node.js

Python

Paramètres intégrés

Node.js

Python

Paramètres secrets

Node.js

Python

Secrets JSON structurés

Variables d'environnement

Node.js

Python

Déployer plusieurs ensembles de variables d'environnement

Variables d'environnement réservées

Stocker des informations de configuration sensibles et y accéder

Créer et utiliser un secret

Node.js

Python

Node.js

Python

Gérer les secrets

Facturation des secrets

Prise en charge des émulateurs

Secrets et identifiants dans l'émulateur Cloud Functions

Migrer à partir de la configuration d'exécution

Variables d'environnement renseignées automatiquement

Configurer votre environnement