Écrire des fonctions Cloud pour une extension

Lorsque vous créez une extension, vous écrivez sa logique à l'aide de Cloud Functions, de la même manière que vous écririez une fonction qui ne serait utilisée que dans votre propre projet. Vous déclarez vos fonctions dans le fichier extension.yaml. Lorsque les utilisateurs installent votre extension, ces fonctions sont déployées dans leur projet.

Consultez la documentation sur Cloud Functions pour obtenir des informations générales sur l'utilisation de Cloud Functions.

Cloud Functions de 1re et 2e générations

Firebase est compatible avec les Cloud Functions de 1re et 2e générations. Cependant, les extensions Firebase présentent actuellement certaines restrictions concernant la génération de fonction cloud que vous pouvez utiliser avec certains types de déclencheurs. C'est pourquoi de nombreuses extensions incluent un mélange de fonctions de 1re et de 2e génération.

La compatibilité avec la génération de fonctions est indiquée pour chaque type de déclencheur ci-dessous.

Considérations particulières

• Certaines définitions de fonction nécessitent de spécifier des informations qui sont également spécifiées dans le fichier extension.yaml. Par exemple, Cloud Firestore dispose d'une méthode document() qui spécifie le modèle de document à surveiller, et sa déclaration correspondante dans extension.yaml comporte un champ resource qui spécifie la même chose.

  Dans ce cas, la configuration spécifiée dans le fichier extension.yaml est utilisée et celle spécifiée dans la définition de la fonction est ignorée.

  Il est courant de spécifier la valeur configurée dans la définition de la fonction, quelle qu'elle soit, à des fins de documentation. Les exemples de cette page suivent ce modèle.

• Le SDK Cloud Functions de 1re génération dispose d'une méthode functions.config() et d'une commande CLI functions:config:set que vous pouvez utiliser pour travailler avec des valeurs de paramètre dans les fonctions de 1re génération. Cette technique est obsolète dans Cloud Functions et ne fonctionnera pas du tout dans une extension. Utilisez plutôt le module functions.params (recommandé) ou process.env.

Utiliser TypeScript ;

La plupart de la documentation sur le développement de votre propre extension décrit les workflows utilisant JavaScript pour Cloud Functions for Firebase. Toutefois, vous pouvez écrire vos fonctions en TypeScript.

En fait, toutes les extensions Firebase officielles sont écrites en TypeScript. Vous pouvez examiner ces extensions pour découvrir les bonnes pratiques d'utilisation de TypeScript pour votre extension.

Si vous écrivez les fonctions de votre extension en TypeScript, vous devez effectuer les opérations suivantes avant d'installer votre extension :

1. Compilez le code source des fonctions de votre extension en JavaScript.

   La commande firebase ext:dev:init vous permet de choisir TypeScript pour écrire vos fonctions. La commande vous fournit une extension complète et installable, ainsi qu'un script de compilation que vous pouvez exécuter avec npm run build.

2. Dans votre fichier package.json, assurez-vous de faire pointer le champ main vers le code JavaScript généré.

3. Si vous installez ou importez votre extension à partir d'une source locale, compilez d'abord vos fichiers TypeScript.

Déclencheurs de fonction compatibles

Déclencheurs HTTP

Une fonction déclenchée par HTTP est déployée sur un point de terminaison https public et s'exécute lorsque l'on accède au point de terminaison.

Pour en savoir plus sur l'écriture de fonctions déclenchées par HTTP, consultez Appeler des fonctions via des requêtes HTTP dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { https } from "firebase-functions/v1";

export const yourFunctionName = https.onRequest(async (req, resp) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      runtime: nodejs16
      httpsTrigger: {}
  - name: anotherFunction
    type: ...

Fonctions appelables

Les fonctions appelables sont semblables aux fonctions déclenchées par HTTP, mais elles implémentent un protocole qui permet de les appeler facilement depuis votre code côté client.

Pour en savoir plus sur l'utilisation des fonctions appelables, consultez Appeler des fonctions depuis votre application dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { https } from "firebase-functions/v1";

export const yourFunctionName = https.onCall(async (data, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      runtime: nodejs16
      httpsTrigger: {}
  - name: anotherFunction
    type: ...

Déclencheurs de fonctions planifiées

Une fonction planifiée s'exécute de manière répétée selon un calendrier personnalisable.

Pour en savoir plus sur l'écriture de fonctions planifiées, consultez Planifier des fonctions dans la documentation de Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { pubsub } from "firebase-functions/v1";

export const yourFunctionName = pubsub.schedule("every 6 hours").onRun((context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      scheduleTrigger:
        schedule: 'every 5 minutes'
  - name: anotherFunction
    type: ...

Voici les sous-champs disponibles pour scheduleTrigger :

Champ	Description
schedule (obligatoire)	Fréquence à laquelle vous souhaitez exécuter la fonction. Ce champ peut accepter des chaînes qui utilisent l'une ou l'autre syntaxe (l'encapsulation dans des guillemets simples est obligatoire) : Syntaxe unix-cron (par exemple, '5 11 * * *') Syntaxe App Engine (par exemple, 'every 5 minutes')
timeZone (facultatif)	Fuseau horaire dans lequel la programmation sera exécutée. Utilisez des abréviations de fuseau horaire standardisées. La valeur par défaut est UTC.

Si vous souhaitez que les utilisateurs puissent configurer la planification lorsqu'ils installent votre extension, ajoutez un nouveau paramètre à votre fichier extension.yaml et référencez-le dans la déclaration resource de votre fonction :

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      scheduleTrigger:
        schedule: ${SCHEDULE_FREQUENCY}
  - name: anotherFunction
    type: ...

params:
  - param: SCHEDULE_FREQUENCY
    label: Schedule
    description: How often do you want to run yourFunctionName()?
    type: string
    default: 'every 5 minutes'  # Specifying a default is optional.
    required: true

Cloud Scheduler permet d'exécuter trois jobs sans frais par compte de facturation. Cette opération ne s'effectue pas au niveau du projet, mais au niveau du compte de facturation. Par conséquent, si plusieurs projets sont associés au même compte de facturation, vous devez connaître le nombre de jobs Cloud Scheduler dont vous disposez. En savoir plus sur la tarification de Cloud Scheduler

Chaque instance installée d'une extension planifiée disposera d'un seul job Cloud Scheduler provisionné pour le projet. Les jobs suspendus sont comptabilisés comme des jobs.

Déclencheurs de file d'attente de tâches

Une fonction de file d'attente de tâches est déclenchée soit lors des événements de cycle de vie de votre extension, soit lorsqu'elle est ajoutée manuellement à la file d'attente de tâches de votre extension à l'aide de la méthode TaskQueue.enqueue() du SDK Admin.

Pour savoir comment écrire des fonctions qui gèrent les événements de cycle de vie, consultez Gérer les événements de cycle de vie de votre extension.

Pour en savoir plus sur l'écriture de fonctions de file d'attente de tâches, consultez Mettre des fonctions en file d'attente avec Cloud Tasks dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { tasks } from "firebase-functions/v1";

export const yourFunctionName = tasks.taskQueue().onDispatch(async (data, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: myTaskFunction
    type: firebaseextensions.v1beta.function
    description: >-
      Perform a task when triggered by a lifecycle event
    properties:
      taskQueueTrigger: {}

Définissez la propriété taskQueueTrigger sur {} ou sur un mappage d'options qui ajustent les limites de débit et le comportement de nouvelle tentative de la file d'attente de tâches (voir Ajuster la file d'attente de tâches).

Si vous souhaitez déclencher votre fonction lors des événements de cycle de vie de votre extension, ajoutez des enregistrements lifecycleEvents avec le nom de la fonction et un message de traitement facultatif, qui s'affichera dans la console Firebase au début du traitement.

lifecycleEvents:
  onInstall:
    function: myTaskFunction
    processingMessage: Resizing your existing images
  onUpdate:
    function: myOtherTaskFunction
    processingMessage: Setting up your extension
  onConfigure:
    function: myOtherTaskFunction
    processingMessage: Setting up your extension

Remarque : Le message que vous spécifiez ici est automatiquement défini comme l'état de traitement de votre extension dans la console Firebase lors du déclenchement de votre fonction. Pour mettre à jour ou effacer l'état de traitement lorsque votre tâche de traitement est terminée, appelez setProcessingState().

Analytics

Une fonction déclenchée par Analytics s'exécute lorsqu'un événement Analytics spécifié est consigné.

Consultez la section Déclencheurs Google Analytics dans la documentation Cloud Functions pour en savoir plus sur l'écriture de fonctions déclenchées par Analytics.

Définition de la fonction (1re génération uniquement)

import { analytics } from "firebase-functions/v1";

export const yourFunctionName = analytics.event("event_name").onLog((event, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/google.firebase.analytics/eventTypes/event.log
        resource: projects/${PROJECT_ID}/events/ga_event
  - name: anotherFunction
    type: ...

Si vous souhaitez que les utilisateurs puissent configurer l'événement Analytics à écouter lorsqu'ils installent votre extension, ajoutez un nouveau paramètre à votre fichier extension.yaml et référencez-le dans la déclaration resource de votre fonction :

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/google.firebase.analytics/eventTypes/event.log
        resource: projects/${PROJECT_ID}/events/${EVENT_NAME}
  - name: anotherFunction
    type: ...

params:
  - param: EVENT_NAME
    label: Analytics event
    description: What event do you want to respond to?
    type: string
    default: ga_event  # Specifying a default is optional.
    required: true

Authentication

Une fonction déclenchée par l'authentification s'exécute lorsqu'un utilisateur est créé ou supprimé.

Pour en savoir plus sur l'écriture de fonctions déclenchées par l'authentification, consultez Déclencheurs Firebase Authentication dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { auth } from "firebase-functions/v1";

export const yourFunctionName = auth.user().onCreate((user, context) => {
  // ...
});

export const yourFunctionName2 = auth.user().onDelete((user, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/firebase.auth/eventTypes/user.create
        resource: projects/${PROJECT_ID}
  - name: anotherFunction
    type: ...

Le tableau suivant montre comment spécifier chacun des types d'événements Authentication compatibles :

Déclencheur d'événement Cloud Functions	eventType	Description
onCreate()	providers/firebase.auth/eventTypes/user.create	Utilisateur créé
onDelete()	providers/firebase.auth/eventTypes/user.delete	Compte utilisateur supprimé

Cloud Firestore

Une fonction déclenchée par Cloud Firestore s'exécute lorsqu'un document est créé, mis à jour ou supprimé.

Pour en savoir plus sur l'écriture de fonctions déclenchées par Firestore, consultez Déclencheurs Cloud Firestore dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { firestore } from "firebase-functions/v1";

export const yourFunctionName = firestore.document("collection/{doc_id}")
  .onCreate((snapshot, context) => {
    // ...
  });

export const yourFunctionName2 = firestore.document("collection/{doc_id}")
  .onUpdate((change, context) => {
    // ...
  });

export const yourFunctionName3 = firestore.document("collection/{doc_id}")
  .onDelete((snapshot, context) => {
    // ...
  });

export const yourFunctionName4 = firestore.document("collection/{doc_id}")
  .onWrite((change, context) => {
    // onWrite triggers on creation, update, and deletion.
    // ...
  });

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/cloud.firestore/eventTypes/document.write
        resource: projects/${PROJECT_ID}/databases/(default)/documents/collection/{documentID}
  - name: anotherFunction
    type: ...

Le tableau suivant montre comment spécifier chacun des types d'événements Cloud Firestore compatibles :

Déclencheur d'événement Cloud Functions	eventType	Description
onCreate()	providers/cloud.firestore/eventTypes/document.create	Le document a bien été créé
onDelete()	providers/cloud.firestore/eventTypes/document.delete	Document supprimé
onUpdate()	providers/cloud.firestore/eventTypes/document.update	Document mis à jour
onWrite()	providers/cloud.firestore/eventTypes/document.write	Document créé, supprimé ou mis à jour

Si vous souhaitez que les utilisateurs puissent configurer le chemin d'accès au document lorsqu'ils installent votre extension, ajoutez un nouveau paramètre à votre fichier extension.yaml et référencez-le dans la déclaration resource de votre fonction :

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/cloud.firestore/eventTypes/document.write
        resource: projects/${PROJECT_ID}/databases/(default)/documents/${YOUR_DOCUMENT_PATH}
  - name: anotherFunction
    type: ...

params:
  - param: YOUR_DOCUMENT_PATH
    label: Cloud Firestore path
    description: Where do you want to watch for changes?
    type: string
    default: path/to/{documentID}  # Specifying a default is optional.
    required: true

Pub/Sub

Une fonction déclenchée par Pub/Sub s'exécute lorsqu'un message est publié dans un sujet spécifique.

Consultez Déclencheurs Pub/Sub dans la documentation Cloud Functions pour en savoir plus sur l'écriture de fonctions déclenchées par Pub/Sub.

Définition de la fonction (1re génération uniquement)

import { pubsub } from "firebase-functions/v1";

export const yourFunctionName = pubsub.topic("topic_name").onPublish((message, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: google.pubsub.topic.publish
        resource: projects/${PROJECT_ID}/topics/topic-name
  - name: anotherFunction
    type: ...

Si vous souhaitez que les utilisateurs puissent configurer le sujet Pub/Sub lorsqu'ils installent votre extension, ajoutez un nouveau paramètre à votre fichier extension.yaml et référencez-le dans la déclaration resource de votre fonction :

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: google.pubsub.topic.publish
        resource: projects/${PROJECT_ID}/topics/${PUBSUB_TOPIC}
  - name: anotherFunction
    type: ...

params:
  - param: PUBSUB_TOPIC
    label: Pub/Sub topic
    description: Which Pub/Sub topic do you want to watch for messages?
    type: string
    default: topic-name  # Specifying a default is optional.
    required: true

Realtime Database

Une fonction déclenchée par Realtime Database s'exécute lorsqu'un chemin d'accès correspondant à un modèle spécifié est créé, mis à jour ou supprimé.

Consultez Déclencheurs Realtime Database dans la documentation Cloud Functions pour savoir comment écrire des fonctions déclenchées par RTDB.

Définition de la fonction (1re génération uniquement)

import { database } from "firebase-functions/v1";

export const yourFunctionName = database.ref("path/to/{item}")
  .onCreate((snapshot, context) => {
    // ...
  });

export const yourFunctionName2 = database.ref("path/to/{item}")
  .onUpdate((change, context) => {
    // ...
  });

export const yourFunctionName3 = database.ref("path/to/{item}")
  .onDelete((snapshot, context) => {
    // ...
  });

export const yourFunctionName4 = database.ref("path/to/{item}")
  .onWrite((change, context) => {
    // onWrite triggers on creation, update, and deletion.
    // ...
  });

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/google.firebase.database/eventTypes/ref.create
        # DATABASE_INSTANCE (project's default instance) is an auto-populated
        # parameter value. You can also specify an instance.
        resource: projects/_/instances/${DATABASE_INSTANCE}/refs/path/to/{itemId}
  - name: anotherFunction
    type: ...

Le tableau suivant montre comment spécifier chacun des types d'événements Cloud Firestore compatibles :

Déclencheur d'événement Cloud Functions	eventType	Description
onCreate()	providers/google.firebase.database/eventTypes/ref.create	Données créées
onDelete()	providers/google.firebase.database/eventTypes/ref.delete	Données supprimées
onUpdate()	providers/google.firebase.database/eventTypes/ref.update	Données mises à jour
onWrite()	providers/google.firebase.database/eventTypes/ref.write	Données créées, supprimées ou mises à jour

Si vous souhaitez que les utilisateurs puissent configurer le chemin d'accès à surveiller lorsqu'ils installent votre extension, ajoutez un nouveau paramètre à votre fichier extension.yaml et référencez-le dans la déclaration resource de votre fonction :

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/google.firebase.database/eventTypes/ref.create
        # DATABASE_INSTANCE (project's default instance) is an auto-populated
        # parameter value. You can also specify an instance.
        resource: projects/_/instances/${DATABASE_INSTANCE}/refs/${DB_PATH}
  - name: anotherFunction
    type: ...

params:
  - param: DB_PATH
    label: Realtime Database path
    description: Where do you want to watch for changes?
    type: string
    default: path/to/{itemId}  # Specifying a default is optional.
    required: true

Remote Config

Une fonction déclenchée par Remote Config s'exécute lorsque le modèle de paramètre d'un projet est mis à jour.

Pour en savoir plus sur l'écriture de fonctions déclenchées par Remote Config, consultez la section Déclencheurs Remote Config dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { remoteConfig } from "firebase-functions/v1";

export const yourFunctionName = remoteConfig.onUpdate((version, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: google.firebase.remoteconfig.update
        resource: projects/${PROJECT_ID}
  - name: anotherFunction
    type: ...

Cloud Storage

Une fonction déclenchée par Cloud Storage s'exécute lorsqu'un objet est créé, archivé ou supprimé, ou lorsque ses métadonnées sont modifiées.

Pour en savoir plus sur l'écriture de fonctions déclenchées par Storage, consultez Déclencheurs Cloud Storage dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { storage } from "firebase-functions/v1";

export const yourFunctionName = storage.object().onFinalize((object, context) => {
  // ...
});

export const yourFunctionName2 = storage.object().onMetadataUpdate((object, context) => {
  // ...
});

export const yourFunctionName3 = storage.object().onArchive((object, context) => {
  // ...
});

export const yourFunctionName4 = storage.object().onDelete((object, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: google.storage.object.finalize
        # STORAGE_BUCKET (project's default bucket) is an auto-populated
        # parameter. You can also specify a bucket.
        resource: projects/_/buckets/${STORAGE_BUCKET}
  - name: anotherFunction
    type: ...

Le tableau suivant montre comment spécifier chacun des types d'événements Cloud Storage compatibles :

Déclencheur d'événement Cloud Functions	eventType	Description
onFinalize()	google.storage.object.finalize	Objet créé
onMetadataUpdate()	google.storage.object.metadataUpdate	Métadonnées d'objet mises à jour
onArchive()	google.storage.object.archive	L'objet a été archivé
onDelete()	google.storage.object.delete	Objet supprimé

Si vous souhaitez que les utilisateurs puissent configurer le bucket de stockage lorsqu'ils installent votre extension, ajoutez un nouveau paramètre à votre fichier extension.yaml et référencez-le dans la déclaration resource de votre fonction :

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: google.storage.object.finalize
        resource: projects/_/buckets/${YOUR_BUCKET}
  - name: anotherFunction
    type: ...

params:
  - param: YOUR_BUCKET
    label: Cloud Storage bucket
    description: Which bucket do you want to watch for changes?
    type: selectResource
    resourceType: storage.googleapis.com/Bucket
    default: ${STORAGE_BUCKET}  # Specifying a default is optional.
    required: true

Test Lab

Une fonction déclenchée par Test Lab s'exécute lorsqu'une matrice de test termine ses tests.

Pour en savoir plus sur l'écriture de fonctions déclenchées par Test Lab, consultez Déclencheurs Firebase Test Lab dans la documentation Cloud Functions.

Définition de la fonction (1re génération uniquement)

import { testLab } from "firebase-functions/v1";

export const yourFunctionName = testLab.testMatrix().onComplete((matrix, context) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourFunctionName
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: google.testing.testMatrix.complete
        resource: projects/${PROJECT_ID}/testMatrices/{matrixId}
  - name: anotherFunction
    type: ...

Crashlytics déclencheur d'alerte

Une fonction déclenchée par Crashlytics s'exécute lorsque Crashlytics publie une alerte.

Pour en savoir plus sur l'écriture de fonctions déclenchées par des alertes, consultez Déclencheurs d'alertes Firebase dans la documentation Cloud Functions.

Définition de la fonction (2e génération uniquement)

import {
  onNewFatalIssuePublished,
  onNewNonfatalIssuePublished,
  onNewAnrIssuePublished,
  onRegressionAlertPublished,
  onVelocityAlertPublished,
  onStabilityDigestPublished,
} from "firebase-functions/v2/alerts/crashlytics";

export const yourFunctionName = onNewFatalIssuePublished((event) => {
  // ...
});

export const yourFunctionName2 = onNewNonfatalIssuePublished((event) => {
  // ...
});

export const yourFunctionName3 = onNewAnrIssuePublished((event) => {
  // ...
});

export const yourFunctionName4 = onRegressionAlertPublished((event) => {
  // ...
});

export const yourFunctionName5 = onVelocityAlertPublished((event) => {
  // ...
});

export const yourFunctionName6 = onStabilityDigestPublished((event) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourfunctionname
    type: firebaseextensions.v1beta.v2function
    properties:
      buildConfig:
        runtime: nodejs16
      serviceConfig:
        availableMemory: 512M
      eventTrigger:
        eventType: google.firebase.firebasealerts.alerts.v1.published
        triggerRegion: global
        eventFilters:
          - attribute: alerttype
            value: crashlytics.newFatalIssue
  - name: anotherFunction
    type: ...

Vous pouvez utiliser les valeurs suivantes pour alerttype :

• crashlytics.newFatalIssue
• crashlytics.newNonfatalIssue
• crashlytics.regression
• crashlytics.stabilityDigest
• crashlytics.velocity
• crashlytics.newAnrIssue

Performance Monitoring déclencheur d'alerte

Une fonction déclenchée par Performance Monitoring s'exécute lorsque Performance Monitoring publie une alerte.

Pour en savoir plus sur l'écriture de fonctions déclenchées par des alertes, consultez Déclencheurs d'alertes Firebase dans la documentation Cloud Functions.

Définition de la fonction (2e génération uniquement)

import { onThresholdAlertPublished } from "firebase-functions/v2/alerts/performance";

export const yourFunctionName = onThresholdAlertPublished((event) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourfunctionname
    type: firebaseextensions.v1beta.v2function
    properties:
      buildConfig:
        runtime: nodejs16
      serviceConfig:
        availableMemory: 512M
      eventTrigger:
        eventType: google.firebase.firebasealerts.alerts.v1.published
        triggerRegion: global
        eventFilters:
          - attribute: alerttype
            value: performance.threshold
  - name: anotherFunction
    type: ...

App Distribution déclencheur d'alerte

Une fonction déclenchée par App Distribution s'exécute lorsque App Distribution publie une alerte.

Pour en savoir plus sur l'écriture de fonctions déclenchées par des alertes, consultez Déclencheurs d'alertes Firebase dans la documentation Cloud Functions.

Définition de la fonction (2e génération uniquement)

import {
  onNewTesterIosDevicePublished,
  onInAppFeedbackPublished
} from "firebase-functions/v2/alerts/appDistribution";

export const yourFunctionName = onNewTesterIosDevicePublished((event) => {
  // ...
});

export const yourFunctionName2 = onInAppFeedbackPublished((event) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourfunctionname
    type: firebaseextensions.v1beta.v2function
    properties:
      buildConfig:
        runtime: nodejs16
      serviceConfig:
        availableMemory: 512M
      eventTrigger:
        eventType: google.firebase.firebasealerts.alerts.v1.published
        triggerRegion: global
        eventFilters:
          - attribute: alerttype
            value: appDistribution.inAppFeedback
  - name: anotherFunction
    type: ...

Vous pouvez utiliser les valeurs suivantes pour alerttype :

• appDistribution.newTesterIosDevice
• appDistribution.inAppFeedback

Déclencheurs d'événements personnalisés (Eventarc)

Une fonction déclenchée par Eventarc s'exécute lorsqu'un type d'événement spécifique est publié sur un canal spécifique.

Pour en savoir plus sur l'écriture de fonctions déclenchées par Eventarc, consultez Créer et gérer des déclencheurs d'événements personnalisés dans la documentation Cloud Functions.

Vous pouvez également publier des événements à partir de vos extensions pour permettre aux utilisateurs d'insérer une logique personnalisée dans votre extension. Consultez Utiliser une logique personnalisée fournie par le développeur dans une extension.

Définition de la fonction (2e génération uniquement)

import { onCustomEventPublished } from "firebase-functions/v2/eventarc";

export const yourFunctionName = onCustomEventPublished((event) => {
  // ...
});

Déclaration de ressource (extension.yaml)

resources:
  - name: yourfunctionname
    type: firebaseextensions.v1beta.v2function
    properties:
      # LOCATION is a user-configured parameter value specified by the user
      # during installation.
      location: ${param:LOCATION}
      buildConfig:
        runtime: nodejs16
      serviceConfig:
        availableMemory: 512M
        timeoutSeconds: 60
      eventTrigger:
        eventType: firebase.extensions.storage-resize-images.v1.complete
        channel: projects/${param:PROJECT_ID}/locations/us-central1/channels/firebase
  - name: anotherFunction
    type: ...

Le canal doit déjà exister lorsque votre extension est installée. Par exemple, si vous dépendez d'événements personnalisés d'une autre extension qui crée le canal, demandez à vos utilisateurs d'installer d'abord cette extension.

L'exemple ci-dessus crée un déclencheur d'événement personnalisé pour le canal Firebase "default" dans la région us-central1. Vous pouvez rendre le nom et la région du canal personnalisables à l'aide de paramètres. Exemple :

params:
  - param: EVENTARC_CHANNEL_NAME
    label: Eventarc channel name
    description: What is the name of the Eventarc channel.
    default: firebase
    type: string
    required: true

resources:
  - name: yourfunctionname
    type: firebaseextensions.v1beta.v2function
    properties:
      location: ${param:LOCATION}
      eventTrigger:
        eventType: firebase.extensions.storage-resize-images.v1.complete
        channel: projects/${param:PROJECT_ID}/locations/${param:LOCATION}/channels/${param:EVENTARC_CHANNEL_NAME}