É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 , et lorsque les utilisateurs installent votre extension, ces fonctions sont déployées dans leur projet.

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

Fonctions Cloud de 1ère et 2ème génération

Firebase prend en charge les fonctions Cloud de 1re et 2e génération . Cependant, les extensions Firebase comportent actuellement certaines restrictions quant à la génération de fonctions cloud que vous pouvez utiliser avec certains types de déclencheurs. Pour cette raison, de nombreuses extensions incluent un mélange de fonctions de 1ère et 2ème génération.

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

Considérations particulières

  • Certaines définitions de fonctions nécessitent que vous spécifiiez des informations également spécifiées dans le fichier extension.yaml . Par exemple, Cloud Firestore possède une méthode document() qui spécifie le modèle de document à surveiller, et sa déclaration correspondante dans extension.yaml possède 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 malgré tout la valeur configurée dans la définition de la fonction, à des fins de documentation. Les exemples sur cette page suivent ce modèle.

  • Le SDK Cloud Functions 1re génération dispose d'une méthode functions.config() et d'une commande CLI functions:config:set que vous pouvez utiliser pour utiliser des valeurs paramétrées 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 permettant de développer votre propre extension décrit les flux de travail utilisant JavaScript pour Cloud Functions pour Firebase. Cependant, vous pouvez plutôt écrire vos fonctions en utilisant TypeScript.

En fait, toutes les extensions officielles de Firebase sont écrites en TypeScript. Vous pouvez consulter ces extensions pour connaître certaines bonnes pratiques permettant d'utiliser TypeScript pour votre extension.

Si vous écrivez les fonctions de votre extension en TypeScript, vous devez procéder comme suit 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 build que vous pouvez exécuter avec npm run build .

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

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

Déclencheurs de fonctions pris en charge

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 lors de l'accès au point de terminaison.

Consultez Appeler des fonctions via des requêtes HTTP dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par HTTP.

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 similaires aux fonctions déclenchées par HTTP, mais elles implémentent un protocole qui facilite leur appel à partir de votre code côté client.

Consultez Appeler des fonctions depuis votre application dans la documentation Cloud Functions pour plus d'informations sur l'utilisation des fonctions appelables.

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és

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

Consultez Fonctions de planification dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions planifiées.

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
(requis)

La fréquence à laquelle vous souhaitez que la fonction s'exécute.

Ce champ peut accepter des chaînes qui utilisent l'une ou l'autre des syntaxes (un emballage entre guillemets simples est requis) :

timeZone
(facultatif)

Le 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 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:
      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 des tâches est déclenchée soit lors des événements du cycle de vie de votre extension, soit lorsqu'elle est ajoutée manuellement à la file d'attente des tâches de votre extension à l'aide de la méthode TaskQueue.enqueue() du SDK Admin.

Consultez Gérer les événements du cycle de vie de votre extension pour plus d’informations sur l’écriture de fonctions qui gèrent les événements du cycle de vie.

Consultez les fonctions Mettre en file d'attente avec Cloud Tasks dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions de file d'attente de tâches.

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 une carte d'options qui ajustent les limites de débit et le comportement des nouvelles tentatives de la file d'attente des tâches (voir Réglage de la file d'attente des tâches ).

Si vous souhaitez déclencher votre fonction sur les événements du cycle de vie de votre extension, ajoutez des enregistrements lifecycleEvents avec le nom de la fonction et un message de traitement facultatif, qui sera affiché 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

Analytique

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

Consultez les déclencheurs Google Analytics dans la documentation Cloud Functions pour plus d'informations 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 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

Authentification

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

Consultez les déclencheurs d'authentification Firebase dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par authentification.

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 d'authentification pris en charge :

Déclencheur d'événement Cloud Functions eventType Description
onCreate() providers/firebase.auth/eventTypes/user.create Nouvel 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é.

Consultez les déclencheurs Cloud Firestore dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par Firestore.

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 pris en charge :

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

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

Consultez les déclencheurs Pub/Sub dans la documentation Cloud Functions pour plus d'informations 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 paramètre 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

Base de données en temps réel

Une fonction déclenchée par la base de données en temps réel s'exécute lorsqu'un chemin correspondant à un modèle spécifié est créé, mis à jour ou supprimé.

Consultez Déclencheurs de base de données en temps réel dans la documentation Cloud Functions pour plus d'informations sur l'écriture de 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 pris en charge :

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

Configuration à distance

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

Consultez Déclencheurs Remote Config dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par Remote Config.

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

Stockage en ligne

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.

Consultez les déclencheurs Cloud Storage dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par Storage.

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 pris en charge :

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 paramètre 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

Laboratoire d'essais

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

Consultez les déclencheurs Firebase Test Lab dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par Test Lab.

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

Déclencheurs d'alerte Crashlytics

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

Consultez les déclencheurs d'alertes Firebase dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par des alertes.

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)

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’alertes de surveillance des performances

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

Consultez les déclencheurs d'alertes Firebase dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par des alertes.

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)

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 de distribution d’applications

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

Consultez les déclencheurs d'alertes Firebase dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par des alertes.

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)

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.

Consultez Créer et gérer des déclencheurs d'événements personnalisés dans la documentation Cloud Functions pour plus d'informations sur l'écriture de fonctions déclenchées par Eventarc.

Vous pouvez également publier des événements à partir de vos extensions pour donner aux utilisateurs un moyen d'insérer une logique personnalisée dans votre extension. Consultez Utiliser la 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)

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

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 la chaîne, demandez à vos utilisateurs d'installer d'abord cette extension.

L'exemple ci-dessus créerait 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 de la chaîne et la région à l'aide de paramètres. Par 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}