É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 de Cloud Functions pour obtenir des informations générales sur l'utilisation de Cloud Functions.

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

Firebase est compatible avec les Cloud Functions de 1re et 2e génération. Toutefois, les extensions Firebase sont actuellement soumises à certaines restrictions concernant la génération de fonctions cloud que vous pouvez utiliser avec certains types de déclencheurs. C'est pourquoi de nombreuses extensions incluent un mélange de fonctions de première et de deuxième 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 vous obligent à 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 ces situations, la configuration spécifiée dans le fichier extension.yaml est utilisée et la configuration 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 que soit la valeur, pour des raisons de documentation. Les exemples de cette page suivent ce modèle.

  • Le SDK de première génération Cloud Functions dispose d'une méthode functions.config() et d'une commande CLI functions:config:set que vous pouvez utiliser pour travailler avec des valeurs paramétrées dans les fonctions de première génération. Cette technique est obsolète dans Cloud Functions et ne fonctionne 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 à la place à l'aide de TypeScript.

En fait, toutes les extensions Firebase officielles sont écrites en TypeScript. Vous pouvez consulter ces extensions pour découvrir les bonnes pratiques à suivre pour utiliser TypeScript dans votre extension.

Si vous écrivez les fonctions de votre extension en TypeScript, vous devez procéder comme suit avant d'installer l'extension:

  1. Complétez 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. Cette commande 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 diriger 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 le point de terminaison est accessible.

Pour en savoir plus sur l'écriture de fonctions déclenchées par HTTP, consultez la section 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 ressources (extension.yaml)

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

Fonctions appelables

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

Pour en savoir plus sur l'utilisation des fonctions appelables, consultez la section 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 ressources (extension.yaml)

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

Déclencheurs de fonction planifiés

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

Pour en savoir plus sur l'écriture de fonctions planifiées, consultez la section Planifier des fonctions dans la documentation 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 ressources (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 entre guillemets simples est obligatoire):
timeZone
(facultatif)

Fuseau horaire dans lequel la planification s'exécutera.

Si vous souhaitez que les utilisateurs puissent configurer la planification lorsqu'ils installent votre extension, ajoutez un 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

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

Une fonction de file d'attente de tâches est déclenchée soit sur les é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.

Consultez la section Gérer les événements de cycle de vie de votre extension pour en savoir plus sur l'écriture des fonctions qui gèrent les événements de cycle de vie.

Pour en savoir plus sur l'écriture de fonctions de file d'attente de tâches, consultez la section 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 ressources (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 une carte 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 sur les é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

Analytics

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

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

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 ressources (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 paramètre 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 savoir comment écrire des fonctions déclenchées par l'authentification, consultez la section 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 ressources (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 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 la section 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 ressources (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:

Cloud Functions déclencheur d'événement eventType Description
onCreate() providers/cloud.firestore/eventTypes/document.create Document 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 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.

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

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 ressources (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 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é.

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

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 ressources (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:

Cloud Functions déclencheur d'événement 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 à surveiller lorsqu'ils installent votre extension, ajoutez un 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ètres 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 ressources (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 changent.

Pour en savoir plus sur l'écriture de fonctions déclenchées par Storage, consultez la section 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 ressources (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 de l'objet mises à jour
onArchive() google.storage.object.archive Objet 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 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 savoir comment écrire des fonctions déclenchées par Test Lab, consultez la section 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 ressources (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: ...

Déclencheurs d'alerte Crashlytics

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 une alerte, consultez la section 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 ressources (extension.yaml)

apis:
  - apiName: eventarc.googleapis.com
    reason: Powers all events and triggers
  - apiName: run.googleapis.com
    reason: Powers 2nd-gen functions

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

Déclencheurs d'alerte Performance Monitoring

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 la section 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 ressources (extension.yaml)

apis:
  - apiName: eventarc.googleapis.com
    reason: Powers all events and triggers
  - apiName: run.googleapis.com
    reason: Powers 2nd-gen functions

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

Déclencheurs d'alerte App Distribution

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 la section 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 ressources (extension.yaml)

apis:
  - apiName: eventarc.googleapis.com
    reason: Powers all events and triggers
  - apiName: run.googleapis.com
    reason: Powers 2nd-gen functions

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 la section 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 la section 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 ressources (extension.yaml)

apis:
  - apiName: eventarc.googleapis.com
    reason: Powers all events and triggers
  - apiName: run.googleapis.com
    reason: Powers 2nd-gen functions

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

Cette chaîne doit déjà exister lors de l'installation de l'extension. 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 "par défaut" dans la région us-central1. Vous pouvez personnaliser le nom et la région de la chaîne à 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}