Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Gérer le déploiement des fonctions et les options d'exécution

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 de la CLI Firebase :

$ firebase deploy --only functions

Par défaut, la CLI Firebase déploie toutes les fonctions à l' intérieur index.js en même temps. Si votre projet contient plus de 5 fonctions, nous vous recommandons d' utiliser le --only drapeau avec des noms de fonctions spécifiques à déployer uniquement les fonctions que vous avez modifié. Déploiement de fonctions spécifiques ainsi accélère le processus de déploiement et vous aide à éviter de courir dans les quotas de déploiement. Par exemple:

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

Lors du déploiement d'un grand nombre de fonctions, vous pouvez dépasser le quota standard et recevoir des messages d'erreur HTTP 429 ou 500. Pour résoudre ce problème, déployez les fonctions par groupes de 10 ou moins.

Voir la référence Firebase CLI pour la liste complète des commandes disponibles.

Par défaut, le Firebase CLI regarde dans les functions/ dossier pour le code source. Vous pouvez spécifier un autre dossier en ajoutant les lignes suivantes dans firebase.json :

"functions": {
  "source": "another-folder"
}

Supprimer des fonctions

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

  • explicitement dans la CLI Firebase avec functions:delete
  • en utilisant explicitement le menu contextuel dans la liste des fonctions de la console Firebase
  • implictly en supprimant la fonction de index.js avant le déploiement.

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

La suppression explicite de fonction dans la CLI Firebase prend en charge plusieurs arguments ainsi que des groupes de fonctions, et vous permet de spécifier une fonction s'exécutant 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 des fonctions implicites, firebase deploy parse index.js et supprime la production de toutes les fonctions qui ont été retirés du dossier.

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

Si vous renommez ou modifiez les régions ou le déclencheur pour les fonctions qui gèrent le trafic de production, suivez les étapes de cette section pour éviter de perdre des événements pendant la modification. Avant de suivre ces étapes, d' abord vous assurer que votre fonction est idempotent , puisque les deux la nouvelle version et l'ancienne version de votre fonction sera en cours d' exécution en même temps lors du changement.

Renommer une fonction

Pour renommer une fonction, créez une nouvelle version de la fonction renomme dans index.js puis exécutez deux commandes de déploiement distinctes. La première commande déploie la fonction nouvellement nommée et la deuxième commande supprime la version précédemment déployée. Par exemple, si vous avez une fonction appelée webhook que vous souhaitez changer pour webhookNew , réviser le code comme suit:

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

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

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

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 spécifiées régions pour une fonction qui est la manipulation du trafic de production, vous pouvez empêcher la perte de l' événement en effectuant ces étapes dans l' ordre:

  1. Renommez la fonction et modifiez sa ou ses régions comme vous le souhaitez.
  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. Supprimer la fonction précédente.

Par exemple, si vous avez une fonction appelée webhook qui est actuellement dans les fonctions par défaut région de us-central1 , et que vous voulez migrer vers l' asia-northeast1 , vous devez d'abord modifier votre code source pour renommer la fonction et de réviser la région .

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

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

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

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

Déployez ensuite en exécutant :

$ firebase deploy --only functions:webhookAsia

Maintenant , il y a deux fonctions identiques en cours d' exécution: webhook est en cours d' exécution en us-central1 et webhookAsia est en cours d' exécution en asia-northeast1 .

Ensuite, supprimez webhook :

$ firebase functions:delete webhook

Maintenant , il n'y a qu'une seule fonction - webhookAsia , qui est en cours d' exécution en asia-northeast1 .

Modifier le type de déclencheur d'une fonction

Au fur et à mesure que vous développez votre déploiement Cloud Functions for Firebase au fil du temps, vous devrez peut-être modifier le type de déclencheur d'une fonction pour diverses raisons. Par exemple, vous pourriez vouloir :

  • Changement du stockage existants onChange événement onFinalize , onDelete , onArchive et onMetadataUpdate . ( En savoir plus à ce sujet dans la version bêta de mise à niveau Guide v1 ou v2 ).
  • Changement d'un type de Firebase en temps réel Base de données ou d'un événement Nuage Firestore un à l'autre, comme le générique onWrite événement granulaire onCreate événement.

Il est impossible de modifier le type d'événement de fonction en changeant simplement le code source et en cours d' exécution firebase deploy . Pour éviter les erreurs, modifiez le type de déclencheur d'une fonction par cette procédure :

  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 des nouvelles fonctions.
  3. Supprimez explicitement l'ancienne fonction de la production à l'aide de la CLI Firebase.

Par exemple, si vous aviez une fonction objectChanged qui a l'héritage onChange type d'événement, et que vous souhaitez changer pour onFinalize , d' abord renommer la fonction et de le modifier pour avoir le onFinalize type d'événement.

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

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

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

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

Exécutez ensuite les commandes suivantes pour créer d'abord 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 la version d'exécution Node.js et le délai d'expiration par fonction, l'allocation de mémoire et les instances de fonction minimum/maximum.

Définir la version de Node.js

Le SDK Firebase pour Cloud Functions 2.0.0 et versions ultérieures permet une sélection de l'environnement d'exécution Node.js. Vous pouvez choisir d'exécuter toutes les fonctions d'un projet exclusivement sur l'environnement d'exécution correspondant à l'une de ces versions de Node.js prises en charge :

  • Node.js 14
  • Node.js 12
  • Node.js 10
  • Node.js 8 (désapprouvée le 8 Juin 2020) Le déploiement de fonctions aux Node.js 8 exécution a été désactivé dans la CLI Firebase le 15 Décembre 2020. L' exécution des fonctions déjà déployées arrête à un moment donné à l'avenir; si vous avez déployé des fonctions à l'exécution Node.js 8, nous vous recommandons de mise à niveau vers la Node.js 14 exécution .

Pour définir la version de Node.js :

Définissez la version dans le engines champ dans le package.json fichier qui a été créé dans votre functions/ répertoire lors de l' initialisation. Par exemple, pour utiliser la version 14 seulement, modifier cette ligne package.json :

  "engines": {"node": "14"}

Les engines champ est obligatoire; il doit indiquer l' une des versions Node.js pris en charge pour que vous puissiez déployer et fonctions d'exécution. À l' heure actuelle les firebase init functions de 14 firebase init functions définit ce champ à 14 .

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

Pour mettre à niveau votre environnement d'exécution Node.js :

  1. Assurez - vous que votre projet est sur le plan tarifaire Blaze .
  2. Assurez-vous que vous utilisez Firebase CLI v8.6.0 ou version ultérieure.
  3. Changer la engines valeur dans le package.json fichier qui a été créé dans votre functions/ répertoire lors de l' initialisation. Par exemple, si vous mettez à niveau de la version 10 à la version 14, l'entrée devrait ressembler à ceci: "engines": {"node": "14"}
  4. En option, testez vos modifications en utilisant l' émulateur local Firebase Suite .
  5. Redéployez les fonctions à l'aide de Firebase CLI v8.1.0 ou version ultérieure.

Contrôler le comportement de mise à l'échelle

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, en réduisant potentiellement à zéro instance en période de trafic réduit. Toutefois, si votre application nécessite une latence réduite et que vous souhaitez limiter le nombre de démarrages à froid, vous pouvez modifier ce comportement par défaut en spécifiant un nombre minimum d'instances de conteneur à conserver au chaud et prêtes à répondre aux demandes.

De même, vous pouvez définir un nombre maximum pour limiter la mise à l'échelle des instances en réponse aux demandes entrantes. Utilisez ce paramètre comme moyen de contrôler vos coûts ou de limiter le nombre de connexions à un service de support tel qu'une base de données.

Réduire le nombre de démarrages à froid

Pour nombre minimum d'instances fixé pour une fonction dans le code source, utilisez le runWith paramètre. Cette option d'exécution accepte un objet JSON conforme à la RuntimeOptions interface, qui définit la valeur pour minInstances . Par exemple, cette fonction définit un minimum de 5 instances à garder au chaud :

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

Voici quelques points à considérer lors de la définition d' une valeur pour minInstances :

  • Si les fonctions Cloud pour votre application Firebase échelles au- dessus de votre minInstances paramètre, vous ferez l' expérience d' un démarrage à froid pour chaque instance au- dessus de ce seuil.
  • Les démarrages à froid ont l'effet le plus grave sur les applications avec un trafic en pic. Si votre application a un trafic hérissés et que vous définissez une minInstances valeur suffisamment élevée pour que les démarrages à froid sont réduits à chaque augmentation du trafic, vous verrez considérablement réduit la latence. Pour les applications avec un trafic constant, les démarrages à froid ne sont pas susceptibles d'affecter gravement les performances.
  • La définition d'instances minimales peut avoir du sens pour les environnements de production, mais doit généralement être évitée dans les environnements de test. À l' échelle à zéro dans votre projet de test , mais réduire encore les démarrages à froid dans votre projet de production, vous pouvez définir minInstances en fonction de la FIREBASE_CONFIG variable d'environnement:

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

Limiter le nombre maximum d'instances pour une fonction

Pour configurer les instances maximales dans le code source de la fonction, utilisez le runWith paramètre. Cette option d'exécution accepte un objet JSON conforme à la RuntimeOptions interface, qui définit des valeurs pour maxInstances . Par exemple, cette fonction définit une limite de 100 instances afin de ne pas surcharger une hypothétique base de données héritée :

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

Si une fonction HTTP est mise à l' échelle jusqu'à la maxInstances limite, les nouvelles demandes sont mis en attente pendant 30 secondes, puis rejeté avec le code de réponse de 429 Too Many Requests si aucune instance est alors disponible.

Pour en savoir plus sur les meilleures pratiques pour l' utilisation des paramètres des instances maximum, consultez ces meilleures pratiques pour l' utilisation maxInstances .

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

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

Pour l' allocation de mémoire réglée et délai d' attente dans les fonctions code source, utilisez le runWith paramètre introduit dans Firebase SDK pour les fonctions de Cloud 2.0.0. Cette option d'exécution accepte un objet JSON conforme à la RuntimeOptions interface, qui définit des valeurs pour timeoutSeconds et la memory . Par exemple, cette fonction de stockage utilise 1 Go de mémoire et expire au bout de 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
    });

La valeur maximale pour timeoutSeconds est 540 , soit 9 minutes. Les valeurs valides pour la memory sont les suivantes :

  • 128MB
  • 256MB
  • 512MB
  • 1GB
  • 2GB
  • 4GB
  • 8GB

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

  1. Dans la console Google Cloud Google sélectionnez Fonctions nuage dans le menu à 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 principal.
  4. Sélectionnez une allocation de mémoire dans le menu déroulant intitulé La mémoire allouée.
  5. Cliquez sur Plus pour afficher les options avancées, et entrez un nombre de secondes dans la zone de texte Délai d' attente.
  6. Cliquez sur Enregistrer pour mettre à jour la fonction.