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éthodedocument()
qui spécifie le modèle de document à surveiller, et sa déclaration correspondante dansextension.yaml
possède un champresource
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 CLIfunctions: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 modulefunctions.params
(recommandé) ouprocess.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 :
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 avecnpm run build
.Dans votre fichier
package.json
, assurez-vous de pointer le champmain
vers le JavaScript généré.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}