Gérer les fonctions


Vous pouvez déployer, supprimer et modifier des fonctions à l'aide des commandes CLI Firebase. ou en définissant des options d'exécution dans le code source de vos fonctions.

Déployer des fonctions

Pour déployer des fonctions, exécutez cette commande CLI Firebase:

firebase deploy --only functions

Par défaut, la CLI Firebase déploie toutes les fonctions de votre source en même temps. Si votre projet contient plus de cinq fonctions, nous vous recommandons d'utiliser l'indicateur --only avec des noms de fonction spécifiques pour ne déployer que les fonctions que vous avez modifiées. Déployer des fonctions spécifiques Cela accélère le processus de déploiement et vous évite de rencontrer des quotas de déploiement. Exemple :

firebase deploy --only functions:addMessage,functions:makeUppercase

Lorsque vous déployez un grand nombre de fonctions, vous pouvez dépasser le standard et recevoir des messages d'erreur HTTP 429 ou 500. Pour résoudre déployer les fonctions par groupes de 10 ou moins.

Consultez la documentation de référence de la CLI Firebase pour obtenir la liste complète des commandes.

Par défaut, la CLI Firebase recherche dans le dossier functions/ les du code source. Si vous préférez, vous pouvez organiser les fonctions dans des bases de code ou plusieurs ensembles de fichiers.

Supprimer des fonctions

Vous pouvez supprimer des fonctions précédemment déployées de plusieurs manières:

  • explicitement dans la CLI Firebase avec functions:delete.
  • explicitement dans la console Google Cloud.
  • implicitement en supprimant la fonction de la source avant le déploiement.

Toutes les opérations de suppression vous invitent à confirmer avant de supprimer la fonction de production.

La suppression explicite de fonctions dans la CLI Firebase accepte plusieurs arguments ainsi que les fonctions et vous permet de spécifier une fonction qui s'exécute dans une région particulière. Vous pouvez également ignorer l'invite de confirmation.

# Delete all functions that match the specified name in all regions.
firebase functions:delete myFunction

# Delete a specified function running in a specific region.
firebase functions:delete myFunction --region us-east-1

# Delete more than one function
firebase functions:delete myFunction myOtherFunction

# Delete a specified functions group.
firebase functions:delete groupA

# Bypass the confirmation prompt.
firebase functions:delete myFunction --force

Avec la suppression de fonction implicite, firebase deploy analyse votre source et supprime de la production toutes les fonctions qui ont été supprimées du fichier.

Modifier le nom, la région ou le déclencheur d'une fonction

Si vous renommez ou modifiez les régions, ou déclenchez des fonctions de production, suivez les étapes de cette section pour éviter de perdre lors de la modification. Avant de suivre ces étapes, assurez-vous que votre est idempotente, car la nouvelle et l'ancienne version de votre fonction s'exécuteront en même temps pendant le changement.

Renommer une fonction

Pour renommer une fonction, créez une nouvelle version renommée de la fonction dans votre source puis exécuter deux commandes de déploiement distinctes. La première commande déploie que vous venez de nommer, et la seconde commande supprime la fonction précédemment déployée version. Par exemple, si vous souhaitez remplacer une fonction Node.js appelée webhook par webhookNew, modifiez le code comme suit :

// before
const functions = require('firebase-functions/v1');

exports.webhook = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

// after
const functions = require('firebase-functions/v1');

exports.webhookNew = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

Exécutez ensuite les commandes suivantes pour déployer la nouvelle fonction:

# Deploy new function called webhookNew
firebase deploy --only functions:webhookNew

# Wait until deployment is done; now both webhookNew and webhook are running

# Delete webhook
firebase functions:delete webhook

Modifier la ou les régions d'une fonction

Si vous modifiez les régions spécifiées pour une qui gère le trafic de production, vous pouvez empêcher la perte d'événements en effectuant ces étapes dans l'ordre:

  1. Renommez la fonction et modifiez sa ou ses régions selon vos besoins.
  2. Déployez la fonction renommée, ce qui entraîne l'exécution temporaire du même code dans les deux ensembles de régions.
  3. Supprimez la fonction précédente.

Par exemple, si vous avez une fonction appelée webhook, qui se trouve actuellement par défaut de la région us-central1, que vous souhaitez migrer vers asia-northeast1, vous devez d'abord modifier le code source pour renommer le et réviser la région.

// before
const functions = require('firebase-functions/v1');

exports.webhook = functions
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

// after
const functions = require('firebase-functions/v1');

exports.webhookAsia = functions
    .region('asia-northeast1')
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

Ensuite, déployez en exécutant la commande suivante:

firebase deploy --only functions:webhookAsia

Deux fonctions identiques s'exécutent maintenant: webhook s'exécute dans us-central1, et webhookAsia s'exécute dans asia-northeast1.

Supprimez ensuite webhook:

firebase functions:delete webhook

Il n'y a plus qu'une seule fonction webhookAsia, qui s'exécute dans asia-northeast1.

Modifier le type de déclencheur d'une fonction

Au fur et à mesure du développement de votre déploiement Cloud Functions for Firebase, vous devrez peut-être modifier le type de déclencheur d'une fonction pour diverses raisons. Par exemple, vous pouvez passer d'un type d'événement Firebase Realtime Database ou Cloud Firestore à un autre.

Il n'est pas possible de modifier le type d'événement d'une fonction en modifiant simplement le code source et en exécutant firebase deploy. Pour éviter les erreurs, modifier le type de déclencheur d'une fonction en procédant comme suit:

  1. Modifiez le code source pour inclure une nouvelle fonction avec le type de déclencheur souhaité.
  2. Déployez la fonction, ce qui entraîne l'exécution temporaire des anciennes et nouvelles fonctions.
  3. Supprimez explicitement l'ancienne fonction de production à l'aide de la CLI Firebase.

Par exemple, si vous aviez une fonction Node.js nommée objectChanged qui utilise l'ancien type d'événement onChange et que vous souhaitez la remplacer par onFinalize, commencez par renommer la fonction et modifiez-la pour qu'elle utilise le type d'événement onFinalize.

// before
const functions = require('firebase-functions/v1');

exports.objectChanged = functions.storage.object().onChange((object) => {
    return console.log('File name is: ', object.name);
});

// after
const functions = require('firebase-functions/v1');

exports.objectFinalized = functions.storage.object().onFinalize((object) => {
    return console.log('File name is: ', object.name);
});

Exécutez ensuite les commandes suivantes pour créer la nouvelle fonction avant de supprimer l'ancienne fonction:

# Create new function objectFinalized
firebase deploy --only functions:objectFinalized

# Wait until deployment is done; now both objectChanged and objectFinalized are running

# Delete objectChanged
firebase functions:delete objectChanged

Définir les options d'exécution

Cloud Functions for Firebase vous permet de sélectionner des options d'exécution telles que Node.js la version d'exécution et le délai avant expiration par fonction, l'allocation de mémoire et instances de fonction.

Ces options (à l'exception de la version de Node.js) doivent être définies sur un objet de configuration dans le code de la fonction. Ce RuntimeOptions est la source de référence pour les options d'exécution de votre fonction et les options de remplacement définies via toute autre méthode (par exemple, via la console Google Cloud) ou gcloud CLI).

Si votre workflow de développement implique de définir manuellement des options d'exécution via la console Google Cloud ou gcloud CLI, et vous ne souhaitez pas que ces valeurs soient remplacée à chaque déploiement, définissez l'option preserveExternalChanges sur true. Lorsque cette option est définie sur true, Firebase fusionne les options d'exécution définies dans votre avec les paramètres de la version actuellement déployée de votre fonction la priorité suivante:

  1. L'option est définie dans le code des fonctions: ignorer les modifications externes.
  2. L'option est définie sur RESET_VALUE dans le code des fonctions : remplacez les modifications externes par la valeur par défaut.
  3. L'option n'est pas définie dans le code des fonctions, mais dans la fonction actuellement déployée : utilisez l'option spécifiée dans la fonction déployée.

L'utilisation de l'option preserveExternalChanges: true n'est pas recommandée. dans la plupart des cas, car votre le code ne sera plus la source de référence complète pour les options d'exécution fonctions. Si vous l'utilisez, consultez la console Google Cloud ou utilisez la commande CLI pour afficher la configuration complète d'une fonction.

Définir la version de Node.js

Le SDK Firebase pour Cloud Functions permet de sélectionner un environnement d'exécution Node.js. Vous pouvez choisir d'exécuter toutes les fonctions d'un projet exclusivement dans l'environnement d'exécution correspondant à l'une des versions compatibles de Node.js suivantes:

  • Node.js 20 (preview)
  • Node.js 18
  • Node.js 16
  • Node.js 14

Pour définir la version de Node.js, procédez comme suit:

Vous pouvez définir la version dans le champ engines de package.json. créé dans votre répertoire functions/ lors de l'initialisation. Par exemple, pour n'utiliser que la version 18, modifiez cette ligne dans package.json :

  "engines": {"node": "18"}

Si vous utilisez le gestionnaire de paquets Yarn ou si vous avez d'autres exigences spécifiques pour le champ engines, vous pouvez définir l'environnement d'exécution du SDK Firebase pour Cloud Functions dans firebase.json à la place :

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
    }
  }

La CLI utilise la valeur définie dans firebase.json plutôt que n'importe quelle valeur ou que vous avez définie séparément dans package.json.

Mettre à niveau votre environnement d'exécution Node.js

Pour mettre à niveau votre environnement d'exécution Node.js, procédez comme suit:

  1. Assurez-vous que votre projet se trouve sur Forfait Blaze.
  2. Assurez-vous d'utiliser la CLI Firebase version 11.18.0 ou ultérieure.
  3. Modifiez la valeur engines dans le fichier package.json créé dans votre répertoire functions/ lors de l'initialisation. Par exemple, si vous passez de la version 16 à la version 18, l'entrée doit se présenter comme suit: "engines": {"node": "18"}
  4. Vous pouvez également tester vos modifications à l'aide de la méthode Firebase Local Emulator Suite
  5. Redéployez toutes les fonctions.

Contrôler le comportement du scaling

Par défaut, Cloud Functions for Firebase adapte le nombre d'instances en cours d'exécution en fonction du nombre de requêtes entrantes, et peut réduire le nombre d'instances à zéro en cas de trafic réduit. Toutefois, si votre application nécessite moins et que vous souhaitez limiter le nombre de démarrages à froid, vous pouvez modifier par défaut en spécifiant un nombre minimal d'instances de conteneur gardé en chaud et prêt à traiter les demandes.

De même, vous pouvez définir un nombre maximal pour limiter le scaling des instances dans en réponse aux requêtes entrantes. Utilisez ce paramètre pour contrôler vos coûts ou pour limiter le nombre de connexions à un service externe base de données.

Réduire le nombre de démarrages à froid

Pour définir un nombre minimal d'instances pour une fonction dans le code source, utilisez la méthode runWith. Cette méthode accepte un objet JSON conforme à l'interface RuntimeOptions, qui définit la valeur de minInstances. Par exemple, cette fonction définit un minimum de 5 instances à maintenir en phase:

exports.getAutocompleteResponse = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      minInstances: 5,
    })
    .https.onCall((data, context) => {
      // Autocomplete a user's search term
    });
index.js

Voici quelques éléments à prendre en compte lorsque vous définissez une valeur pour minInstances:

  • Si Cloud Functions for Firebase met à l'échelle votre application au-delà de votre paramètre minInstances, un démarrage à froid se produira pour chaque instance au-dessus de ce seuil.
  • Les démarrages à froid ont l'effet le plus grave sur les applications dont le trafic est dense. Si votre l'application enregistre un trafic dense et vous avez défini une valeur minInstances suffisamment élevée pour que les démarrages à froid sont réduits à chaque augmentation du trafic, vous constaterez que une latence réduite. Pour les applications dont le trafic est constant, les démarrages à froid ne sont pas susceptibles d'affecter gravement les performances.

  • Définir un nombre minimal d'instances peut être utile pour les environnements de production, mais il est généralement préférable de l'éviter dans les environnements de test. Pour réduire à zéro la mise à l'échelle dans votre projet de test, tout en réduisant les démarrages à froid dans votre projet de production, vous pouvez définir minInstances en fonction de la variable d'environnement FIREBASE_CONFIG :

    // Get Firebase project id from `FIREBASE_CONFIG` environment variable
const envProjectId = JSON.parse(process.env.FIREBASE_CONFIG).projectId;

exports.renderProfilePage = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      // in production only. Default to 0 for test projects.
      minInstances: envProjectId === "my-production-project" ? 5 : 0,
    })
    .https.onRequest((req, res) => {
      // render some html
    });
    index.js

Limiter le nombre maximal d'instances pour une fonction

Pour définir le nombre maximal d'instances dans le code source de la fonction, utilisez la méthode runWith . Cette méthode accepte un objet JSON conforme à la RuntimeOptions de commande, qui définit pour maxInstances. Par exemple, cette fonction définit une limite de 100 afin de ne pas surcharger une ancienne base de données hypothétique:

exports.mirrorOrdersToLegacyDatabase = functions
    .runWith({
      // Legacy database only supports 100 simultaneous connections
      maxInstances: 100,
    })
    .firestore.document("orders/{orderId}")
    .onWrite((change, context) => {
      // Connect to legacy database
    });
index.js

Si le scaling à la hausse d'une fonction HTTP est jusqu'à la limite maxInstances, les nouvelles requêtes sont mis en file d'attente pendant 30 secondes, puis rejeté avec le code de réponse suivant : 429 Too Many Requests si aucune instance n'est disponible d'ici cette date.

Pour en savoir plus sur les bonnes pratiques d'utilisation des paramètres de nombre maximal d'instances, consultez CANNOT TRANSLATE bonnes pratiques d'utilisation de maxInstances.

Définir le délai avant expiration et l'allocation de mémoire

Dans certains cas, vos fonctions peuvent avoir des exigences particulières pour un délai d'inactivité long ou une allocation importante de la mémoire. Vous pouvez définir ces valeurs dans la section Console Google Cloud ou dans le code source de la fonction (Firebase uniquement).

Pour définir l'allocation de mémoire et le délai avant expiration dans le code source des fonctions, utilisez la méthode runWith introduit dans le SDK Firebase pour Cloud Functions 2.0.0. Cette option d'exécution accepte un objet JSON conforme à la RuntimeOptions qui définit les valeurs de timeoutSeconds et memory. Par exemple, cette fonction de stockage utilise 1 Go de mémoire et expire après 300 secondes:

exports.convertLargeFile = functions
    .runWith({
      // Ensure the function has enough memory and time
      // to process large files
      timeoutSeconds: 300,
      memory: "1GB",
    })
    .storage.object()
    .onFinalize((object) => {
      // Do some complicated things that take a lot of memory and time
    });
index.js

La valeur maximale de timeoutSeconds est 540, soit 9 minutes. La quantité de mémoire accordée à une fonction correspond au processeur alloué à la fonction, comme indiqué dans cette liste de valeurs valides pour memory :

  • 128MB — 200MHz
  • 256MB – 400 MHz
  • 512MB – 800 MHz
  • 1GB : 1,4 GHz
  • 2GB : 2,4 GHz
  • 4GB : 4,8 GHz
  • 8GB : 4,8 GHz

Pour définir l'allocation de mémoire et le délai avant expiration dans la console Google Cloud:

  1. Dans la console Google Google Cloud, sélectionnez Cloud Functions dans menu de gauche.
  2. Sélectionnez une fonction en cliquant sur son nom dans la liste des fonctions.
  3. Cliquez sur l'icône Modifier dans le menu supérieur.
  4. Sélectionnez une allocation de mémoire dans le menu déroulant intitulé Mémoire allouée.
  5. Cliquez sur Plus pour afficher les options avancées, puis saisissez un nombre de secondes dans la zone de texte Délai avant expiration.
  6. Cliquez sur Enregistrer pour mettre à jour la fonction.