Scrivi funzioni Cloud Functions per un'estensione

Quando crei un'estensione, scrivi la sua logica utilizzando Cloud Functions, in modo molto simile a come scriveresti una funzione che verrebbe utilizzata solo in tuo progetto. Dichiari le funzioni nel file extension.yaml e, quando gli utenti installano l'estensione, queste funzioni vengono sottoposte a deployment nel loro progetto.

Per informazioni generali sull'utilizzo di Cloud Functions, consulta la documentazione Cloud Functions.

1ª e 2ª generazione Cloud Functions

Firebase supporta sia Cloud Functions di 1ª generazione sia di 2ª generazione Cloud Functions. Tuttavia, le estensioni Firebase attualmente hanno alcune limitazioni sulla generazione di Cloud Functions che puoi utilizzare con determinati tipi di trigger. Per questo motivo, molte estensioni includono un mix di funzioni di 1ª e 2ª generazione.

Il supporto per la generazione di funzioni è indicato di seguito per ogni tipo di trigger.

Considerazioni speciali

  • Alcune definizioni di funzioni richiedono di specificare informazioni che vengono specificate anche nel file extension.yaml. Ad esempio, Cloud Firestore ha un metodo document() che specifica il pattern del documento da monitorare e la relativa dichiarazione in extension.yaml ha un campo resource che specifica lo stesso pattern.

    In questi casi, viene utilizzata la configurazione specificata nel file extension.yaml e la configurazione specificata nella definizione della funzione viene ignorata.

    È prassi comune specificare comunque il valore configurato nella definizione della funzione, per motivi di documentazione. Gli esempi in questa pagina seguono questo pattern.

  • L'SDK di 1ª generazione Cloud Functions ha un metodo functions.config() e un comando CLI functions:config:set che puoi utilizzare per lavorare con i valori con parametri nelle funzioni di 1ª generazione. Questa tecnica è obsoleta in Cloud Functions e non funzionerà affatto in un'estensione. In alternativa, utilizza il modulo functions.params (consigliato) o process.env.

Utilizzo di TypeScript

La maggior parte della documentazione per lo sviluppo della tua estensione descrive i flussi di lavoro che utilizzano JavaScript per Cloud Functions for Firebase. Tuttavia, puoi scrivere le funzioni utilizzando TypeScript.

Infatti, tutte le estensioni Firebase ufficiali sono scritte in TypeScript. Puoi esaminare queste estensioni per alcune best practice per utilizzare TypeScript per la tua estensione.

Se scrivi le funzioni dell'estensione in TypeScript, devi eseguire le seguenti operazioni prima di installare l'estensione:

  1. Compila il codice sorgente delle funzioni dell'estensione in JavaScript.

    Il firebase ext:dev:init comando ti consente di scegliere TypeScript per scrivere le funzioni. Il comando ti fornisce un'estensione completa e installabile e uno script di build che puoi eseguire con npm run build.

  2. Nel file package.json, assicurati che il campo main punti al JavaScript generato.

  3. Se stai installando o caricando l'estensione da una sorgente locale, compila prima i file TypeScript.

Trigger di funzioni supportati

Trigger HTTP

Una funzione attivata da HTTP viene sottoposta a deployment in un endpoint https pubblico e viene eseguita quando si accede all'endpoint.

Per informazioni sulla scrittura di funzioni attivate da HTTP, consulta Chiamare le funzioni tramite richieste HTTP nella Cloud Functions documentazione.

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (extension.yaml)

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

Funzioni richiamabili

Le funzioni richiamabili sono simili alle funzioni attivate da HTTP, ma implementano un protocollo che le rende comode da chiamare dal codice lato client.

Per informazioni sull'utilizzo delle funzioni richiamabili, consulta Chiamare le funzioni dalla tua app nella documentazione Cloud Functions.

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (extension.yaml)

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

Trigger di funzioni pianificate

Una funzione pianificata viene eseguita ripetutamente in base a una pianificazione personalizzabile.

Per informazioni sulla scrittura di funzioni pianificate, consulta Pianificare le funzioni nella documentazione Cloud Functions per

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (extension.yaml)

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

Di seguito sono riportati i campi secondari disponibili per scheduleTrigger:

Campo Descrizione
schedule
(obbligatorio)

La frequenza con cui vuoi che la funzione venga eseguita.

Questo campo può accettare stringhe che utilizzano una delle seguenti sintassi (è necessario racchiuderle tra virgolette singole ):
timeZone
(facoltativo)

Il fuso orario in cui verrà eseguita la pianificazione.

Se vuoi che gli utenti possano configurare la pianificazione quando installano l'estensione, aggiungi un nuovo parametro al file extension.yaml e fai riferimento al parametro nella dichiarazione resource della funzione:

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

Trigger di code di attività

Una funzione della coda di attività viene attivata in base agli eventi del ciclo di vita dell'estensione o quando viene aggiunta manualmente alla coda di attività dell'estensione utilizzando il metodo TaskQueue.enqueue() dell'Admin SDK.

Per informazioni sulla scrittura di funzioni che gestiscono gli eventi del ciclo di vita, consulta Gestire gli eventi del ciclo di vita dell'estensione.

Per informazioni sulla scrittura di funzioni della coda di attività, consulta Accodare le funzioni con Cloud Tasks nella Cloud Functions documentazione.

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (extension.yaml)

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

Imposta la proprietà taskQueueTrigger su {} o su una mappa di opzioni che ottimizzano i limiti di frequenza e il comportamento di ripetizione della coda di attività (vedi Ottimizzare la coda di attività).

Se vuoi attivare la funzione in base agli eventi del ciclo di vita dell'estensione, aggiungi lifecycleEvents record con il nome della funzione e un messaggio di elaborazione facoltativo, che verrà visualizzato nella Firebase console all'inizio dell'elaborazione.

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

Una funzione attivata da Analytics viene eseguita quando viene registrato un evento di Analytics specificato.

Per informazioni sulla scrittura di funzioni attivate da Analytics, consulta Trigger di Google Analytics nella documentazione perCloud Functions.

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (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: ...

Se vuoi che gli utenti possano configurare l'evento Analytics da monitorare quando installano l'estensione, aggiungi un nuovo parametro al file extension.yaml e fai riferimento al parametro nella dichiarazione resource della funzione:

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

Una funzione attivata dall'autenticazione viene eseguita quando viene creato o eliminato un utente.

Per informazioni sulla scrittura di funzioni attivate dall'autenticazione, consulta Trigger di Firebase Authentication nella Cloud Functions documentazione.

Definizione della funzione (solo 1ª generazione)

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

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

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

Dichiarazione delle risorse (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: ...

La tabella seguente mostra come specificare ciascuno dei tipi di eventi supportati:Authentication

Cloud Functions trigger di eventi eventType Descrizione
onCreate() providers/firebase.auth/eventTypes/user.create Nuovo utente creato
onDelete() providers/firebase.auth/eventTypes/user.delete Utente eliminato

Cloud Firestore

Una funzione attivata da Cloud Firestore viene eseguita quando viene creato, aggiornato o eliminato un documento.

Per informazioni sulla scrittura di funzioni attivate da Firestore, consulta Trigger di Cloud Firestore nella documentazione Cloud Functions per.

Definizione della funzione (solo 1ª generazione)

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.
    // ...
  });

Dichiarazione delle risorse (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: ...

La tabella seguente mostra come specificare ciascuno dei tipi di Cloud Firestore eventi supportati:

Cloud Functions trigger di eventi eventType Descrizione
onCreate() providers/cloud.firestore/eventTypes/document.create Nuovo documento creato
onDelete() providers/cloud.firestore/eventTypes/document.delete Documento eliminato
onUpdate() providers/cloud.firestore/eventTypes/document.update Documento aggiornato
onWrite() providers/cloud.firestore/eventTypes/document.write Documento creato, eliminato o aggiornato

Se vuoi che gli utenti possano configurare il percorso del documento quando installano l'estensione, aggiungi un nuovo parametro al file extension.yaml e fai riferimento al parametro nella dichiarazione resource della funzione:

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

Una funzione attivata da Pub/Sub viene eseguita quando un messaggio viene pubblicato in un argomento specifico.

Per informazioni sulla scrittura di funzioni attivate da Pub/Sub, consulta Trigger di Pub/Sub nella documentazione Cloud Functions per.

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (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: ...

Se vuoi che gli utenti possano configurare l'argomento Pub/Sub quando installano l'estensione, aggiungi un nuovo parametro al file extension.yaml e fai riferimento al parametro nella dichiarazione resource della funzione:

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

Una funzione attivata da Realtime Database viene eseguita quando viene creato, aggiornato o eliminato un percorso che corrisponde a un pattern specificato.

Per informazioni sulla scrittura di funzioni attivate da RTDB, consulta Trigger di Realtime Database nella documentazione Cloud Functions.

Definizione della funzione (solo 1ª generazione)

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.
    // ...
  });

Dichiarazione delle risorse (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: ...

La tabella seguente mostra come specificare ciascuno dei tipi di Cloud Firestore eventi supportati:

Cloud Functions trigger di eventi eventType Descrizione
onCreate() providers/google.firebase.database/eventTypes/ref.create Dati creati
onDelete() providers/google.firebase.database/eventTypes/ref.delete Dati eliminati
onUpdate() providers/google.firebase.database/eventTypes/ref.update Dati aggiornati
onWrite() providers/google.firebase.database/eventTypes/ref.write Dati creati, eliminati o aggiornati

Se vuoi che gli utenti possano configurare il percorso da monitorare quando installano l'estensione, aggiungi un nuovo parametro al file extension.yaml e fai riferimento al parametro nella dichiarazione resource della funzione:

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

Una funzione attivata da Remote Config viene eseguita quando viene aggiornato il modello di parametri di un progetto.

Per informazioni sulla scrittura di funzioni attivate da Remote Config, consulta Trigger di Remote Config nella documentazione Cloud Functions per.

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (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

Una funzione attivata da Cloud Storage viene eseguita quando un oggetto viene creato, archiviato o eliminato oppure quando i relativi metadati vengono modificati.

Per informazioni sulla scrittura di funzioni attivate da Storage, consulta Trigger di Cloud Storage nella documentazione Cloud Functions per.

Definizione della funzione (solo 1ª generazione)

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) => {
  // ...
});

Dichiarazione delle risorse (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: ...

La tabella seguente mostra come specificare ciascuno dei tipi di Cloud Storage evento supportati:

Cloud Functions trigger di eventi eventType Descrizione
onFinalize() google.storage.object.finalize Oggetto creato
onMetadataUpdate() google.storage.object.metadataUpdate Metadati dell'oggetto aggiornati
onArchive() google.storage.object.archive L'oggetto è stato archiviato
onDelete() google.storage.object.delete Oggetto eliminato

Se vuoi che gli utenti possano configurare il bucket di archiviazione quando installano l'estensione, aggiungi un nuovo parametro al file extension.yaml e fai riferimento al parametro nella dichiarazione resource della funzione:

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

Una funzione attivata da Test Lab viene eseguita quando una matrice di test termina i test.

Per informazioni sulla scrittura di funzioni attivate da Test Lab, consulta Trigger di Firebase Test Lab nella documentazione Cloud Functions.

Definizione della funzione (solo 1ª generazione)

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

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

Dichiarazione delle risorse (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: ...

Trigger di avvisi di Crashlytics

Una funzione attivata da Crashlytics viene eseguita quando Crashlytics pubblica un avviso.

Per informazioni sulla scrittura di funzioni attivate da avvisi, consulta Trigger di avvisi Firebase nella documentazione Cloud Functions per.

Definizione della funzione (solo 2ª generazione)

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) => {
  // ...
});

Dichiarazione delle risorse (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: ...

Puoi utilizzare i seguenti valori per alerttype

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

Performance Monitoring trigger di avvisi

Una funzione attivata da Performance Monitoring viene eseguita quando Performance Monitoring pubblica un avviso.

Per informazioni sulla scrittura di funzioni attivate da avvisi, consulta Trigger di avvisi Firebase nella documentazione Cloud Functions per.

Definizione della funzione (solo 2ª generazione)

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

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

Dichiarazione delle risorse (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: ...

Trigger di avvisi di App Distribution

Una funzione attivata da App Distribution viene eseguita quando App Distribution pubblica un avviso.

Per informazioni sulla scrittura di funzioni attivate da avvisi, consulta Trigger di avvisi Firebase nella documentazione Cloud Functions per.

Definizione della funzione (solo 2ª generazione)

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

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

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

Dichiarazione delle risorse (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: ...

Puoi utilizzare i seguenti valori per alerttype

  • appDistribution.newTesterIosDevice
  • appDistribution.inAppFeedback

Trigger di eventi personalizzati (Eventarc)

Una funzione attivata da Eventarc viene eseguita quando un tipo di evento specifico viene pubblicato in un canale specifico.

Per informazioni sulla scrittura di funzioni attivate da Eventarc, consulta Creare e gestire trigger di eventi personalizzati nella Cloud Functions documentazione.

Puoi anche pubblicare eventi dalle tue estensioni per consentire agli utenti di inserire logica personalizzata nella tua estensione. Consulta Utilizzare la logica personalizzata fornita dallo sviluppatore in un' estensione.

Definizione della funzione (solo 2ª generazione)

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

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

Dichiarazione delle risorse (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: ...

Il canale deve esistere già al momento dell'installazione dell'estensione. Ad esempio, se dipendi da eventi personalizzati di un'altra estensione che crea il canale, chiedi agli utenti di installare prima l'estensione.

L'esempio precedente creerebbe un trigger di eventi personalizzati per il canale Firebase "default" nella regione us-central1. Puoi rendere personalizzabili il nome e la regione del canale utilizzando i parametri. Ad esempio:


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}