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

Pour obtenir des informations générales sur l'utilisation de Cloud Functions, consultez la Cloud Functions documentation.

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

Firebase est compatible avec les fonctions Cloud de 1re et 2e génération Cloud Functions. 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 1re et 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 fonctions 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 le même modèle.

    Dans ces situations, 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, quoi qu'il arrive, à des fins de documentation. Les exemples de cette page suivent ce modèle.

  • Le SDK Cloud Functions de 1re génération comporte une méthode functions.config() et une commande CLI functions:config:set que vous pouvez utiliser pour travailler avec 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 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 à l'aide de TypeScript.

En fait, toutes les extensions Firebase officielles sont écrites en TypeScript. Vous pouvez consulter ces extensions pour découvrir certaines 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 votre extension :

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

    La firebase ext:dev:init commande vous permet de choisir TypeScript pour écrire vos fonctions. Elle 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 que le champ main pointe 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 fonctions 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 savoir comment écrire des fonctions déclenchées par HTTP, consultez la section Appeler des fonctions via des requêtes HTTP dans la Cloud Functions documentation.

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 semblables aux fonctions déclenchées par HTTP, mais elles implémentent un protocole qui les rend pratiques à appeler à partir de votre code côté client.

Pour savoir comment utiliser 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 fonctions planifiées

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

Pour savoir comment écrire des fonctions planifiées, consultez la section Planifier des fonctions dans la documentation Cloud Functions pour des 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 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
(required)

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

Ce champ peut accepter des chaînes qui utilisent l'une des deux syntaxes (l'encapsulation dans des guillemets simples est obligatoire) :
timeZone
(optional)

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

Si vous souhaitez que les utilisateurs puissent configurer la planification lors de l'installation de votre extension, ajoutez un paramètre au 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 files d'attente de tâches

Une fonction de file d'attente de tâches est déclenchée lors des événements du cycle de vie de votre extension ou 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 du cycle de vie, consultez la section Gérer les événements du cycle de vie de votre extension.

Pour savoir comment écrire des fonctions de file d'attente de tâches, consultez la section Mettre en file d'attente des fonctions avec Cloud Tasks dans la Cloud Functions documentation.

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 ajuste 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 du cycle de vie de votre extension, ajoutez lifecycleEvents enregistrements 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 enregistré.

Pour savoir comment écrire des fonctions déclenchées par Analytics, consultez la section Déclencheurs Google Analytics dans la documentation Cloud Functions pour plus d'informations.

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 lors de l'installation de votre extension, ajoutez un paramètre au 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 savoir comment écrire des fonctions déclenchées par l'authentification, consultez la section Déclencheurs Firebase Authentication dans la Cloud Functions documentation.

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 compatibles Authentication :

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

Pour savoir comment écrire des fonctions déclenchées par Firestore, consultez la section Déclencheurs Cloud Firestore dans la documentation Cloud Functions pour plus d'informations.

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 :

Déclencheur d'événement Cloud Functions 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 lors de l'installation de votre extension, ajoutez un paramètre au 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 savoir comment écrire des fonctions déclenchées par Pub/Sub, consultez la section Déclencheurs Pub/Sub dans la documentation Cloud Functions pour informations.

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 Pub/Sub sujet lors de l'installation de votre extension, ajoutez un paramètre au 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 savoir comment écrire des 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 :

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 lors de l'installation de votre extension, ajoutez un paramètre au 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 lorsqu'un modèle de paramètre de projet est mis à jour.

Pour savoir comment écrire des fonctions déclenchées par Remote Config, consultez la section Déclencheurs Remote Config dans la documentation Cloud Functions pour plus d'informations.

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 sont modifiées.

Pour savoir comment écrire des fonctions déclenchées par Storage, consultez la section Déclencheurs Cloud Storage dans la documentation Cloud Functions pour plus d'informations.

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 d'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 lors de l'installation de votre extension, ajoutez un paramètre au 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 Cloud Functions documentation.

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

Crashlytics déclencheurs d'alertes

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

Pour savoir comment écrire des fonctions déclenchées par des alertes, consultez la section Déclencheurs d'alertes Firebase dans la documentation Cloud Functions pour

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)

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éclencheurs d'alertes

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

Pour savoir comment écrire des fonctions déclenchées par des alertes, consultez la section Déclencheurs d'alertes Firebase dans la documentation Cloud Functions pour

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)

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éclencheurs d'alertes

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

Pour savoir comment écrire des fonctions déclenchées par des alertes, consultez la section Déclencheurs d'alertes Firebase dans la documentation Cloud Functions pour

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)

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 savoir comment écrire des fonctions déclenchées par Eventarc, consultez la section Créer et gérer des déclencheurs d'événements personnalisés dans la Cloud Functions documentation.

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)

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 personnaliser le nom et la région du canal à 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}