Gravar o Cloud Functions para uma extensão

Ao criar uma extensão, você grava a lógica usando o Cloud Functions, da mesma forma que escreveria uma função que só seria usada no seu próprio projeto. Você declara as funções no arquivo extension.yaml e, quando os usuários instalam sua extensão, essas funções são implantadas no projeto.

Consulte a documentação de Cloud Functions para informações gerais sobre o uso Cloud Functions.

1ª e 2ª geração Cloud Functions

O Firebase é compatível com a 1ª e 2ª geração Cloud Functions. No entanto, as Extensões do Firebase atualmente têm algumas restrições sobre qual geração de Função do Cloud você pode usar com determinados tipos de gatilhos. Por esse motivo, muitas extensões incluem uma combinação de funções da 1ª e 2ª geração.

A compatibilidade com a geração de funções é observada para cada tipo de gatilho abaixo.

Considerações especiais

  • Algumas definições de função exigem que você especifique informações que também são especificadas no arquivo extension.yaml. Por exemplo, o Cloud Firestore tem um método document() que especifica o padrão de documento a ser observado, e a declaração correspondente em extension.yaml tem um campo resource que especifica o mesmo.

    Nessas situações, a configuração especificada no arquivo extension.yaml é usada, e a configuração especificada na definição da função é ignorada.

    É uma prática comum especificar o valor configurado na definição de função independentemente da documentação. Os exemplos nesta página seguem esse padrão.

  • O SDK do Cloud Functions de primeira geração tem um método functions.config() e o comando da CLI functions:config:set que você pode usar para trabalhar com valores parametrizados em funções de primeira geração. Essa técnica foi descontinuada em Cloud Functions e não funcionará em uma extensão. Em vez disso, use o módulo functions.params (recomendado) ou process.env.

Como usar o TypeScript

A maior parte da documentação para desenvolver sua própria extensão descreve fluxos de trabalho usando JavaScript para Cloud Functions for Firebase. No entanto, você pode escrever suas funções usando o TypeScript.

Na verdade, todas as extensões oficiais do Firebase são escritas em TypeScript. Você pode analisar essas extensões para ver algumas práticas recomendadas para usar o TypeScript na sua extensão.

Se você escrever as funções de sua extensão no TypeScript, faça o seguinte antes de instalar sua extensão:

  1. Compile o código-fonte das funções da sua extensão para JavaScript.

    O comando firebase ext:dev:init permite que você escolha TypeScript para escrever suas funções. O comando fornece uma extensão completa e instalável, bem como um script de compilação que pode ser executado com npm run build.

  2. No arquivo package.json, aponte o campo main para o JavaScript gerado.

  3. Se você estiver instalando ou fazendo o upload da sua extensão a partir da fonte local, compile os arquivos TypeScript primeiro.

Acionadores de função compatíveis

Gatilhos HTTP

Uma função acionada por HTTP é implantada em um endpoint https público e executada quando o endpoint é acessado.

Consulte Funções de chamada com solicitações HTTP na documentação do Cloud Functions para informações sobre como escrever funções acionadas por HTTP.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (extension.yaml)

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

Funções chamáveis

As funções chamáveis são semelhantes às funções acionadas por HTTP, mas elas implementam um protocolo que as torna chamadas práticas a partir do código do lado do cliente.

Consulte Funções de chamada do app na documentação do Cloud Functions para mais informações sobre como usar funções chamáveis.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (extension.yaml)

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

Gatilhos de função programada

Uma função programada é executada repetidamente com base em uma programação personalizável.

Consulte Funções de programação na documentação do Cloud Functions para informações sobre como escrever funções programadas.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (extension.yaml)

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

Estes são os subcampos disponíveis para scheduleTrigger:

Campo Descrição
schedule
(obrigatório)

A frequência com que você quer que a função seja executada.

Esse campo pode aceitar strings que usam uma sintaxe, em que é necessário colocar aspas simples:
timeZone
(opcional)

É o fuso horário em que a programação será executada.

Se você quiser que os usuários configurem a programação ao instalar a extensão, adicione um novo parâmetro ao arquivo extension.yaml e faça referência ao parâmetro na declaração resource da função:

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

Acionadores da fila de tarefas

Uma função da fila de tarefas é acionada nos eventos de ciclo de vida da extensão ou quando é adicionada manualmente à fila de tarefas usando o método TaskQueue.enqueue() do SDK Admin.

Consulte Gerenciar eventos de ciclo de vida da sua extensão para conferir informações sobre como escrever funções que processam eventos de ciclo de vida.

Consulte Como enfileirar funções com o Cloud Tasks na documentação do Cloud Functions para informações sobre como gravar funções da fila de tarefas.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (extension.yaml)

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

Defina a propriedade taskQueueTrigger como {} ou um mapa de opções que ajustam os limites de taxa e o comportamento de repetição da fila de tarefas. Consulte Como ajustar a fila de tarefas.

Se você quiser acionar a função nos eventos de ciclo de vida da extensão, adicione registros lifecycleEvents com o nome da função e uma mensagem de processamento opcional, que será exibida no console do Firebase durante o início do processamento.

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

Uma função acionada pelo Analytics é executada quando um evento especificado do Analytics é registrado.

Consulte Gatilhos do Google Analytics na documentação do Cloud Functions para sobre como escrever funções acionadas pelo Google Analytics.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (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 você quiser que os usuários configurem o evento do Analytics para detectar, quando instalarem a extensão, adicione um novo parâmetro ao arquivo extension.yaml e faça referência ao parâmetro na declaração resource da função:

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

Uma função acionada por autenticação é executada quando um usuário é criado ou excluído.

Consulte Gatilhos do Firebase Authentication na documentação do Cloud Functions para informações sobre como escrever funções acionadas por autenticação.

Definição da função (apenas 1ª geração)

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

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

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

Declaração de recursos (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: ...

A tabela a seguir mostra como especificar cada um dos tipos de evento Authentication compatíveis:

Gatilho de evento Cloud Functions eventType Descrição
onCreate() providers/firebase.auth/eventTypes/user.create Novo usuário criado
onDelete() providers/firebase.auth/eventTypes/user.delete Usuário excluído

Cloud Firestore

Uma função acionada pelo Cloud Firestore é executada quando um documento é criado, atualizado ou excluído.

Consulte Gatilhos do Cloud Firestore na documentação do Cloud Functions para informações sobre como escrever funções acionadas pelo Firestore.

Definição da função (apenas 1ª geração)

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

Declaração de recursos (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: ...

A tabela a seguir mostra como especificar cada um dos tipos de evento de Cloud Firestore compatíveis:

Gatilho de evento Cloud Functions eventType Descrição
onCreate() providers/cloud.firestore/eventTypes/document.create Novo documento criado
onDelete() providers/cloud.firestore/eventTypes/document.delete Documento excluído
onUpdate() providers/cloud.firestore/eventTypes/document.update Documento atualizado
onWrite() providers/cloud.firestore/eventTypes/document.write Documento criado, excluído ou atualizado

Se você quiser que os usuários possam configurar o caminho do documento ao instalar a extensão, adicione um novo parâmetro ao arquivo extension.yaml e faça referência ao parâmetro na declaração resource da função:

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

Uma função acionada pelo Pub/Sub é executada quando uma mensagem é publicada em um tópico específico.

Consulte Gatilhos do Pub/Sub na documentação do Cloud Functions para informações sobre como escrever funções acionadas pelo Pub/Sub.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (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 você quiser que os usuários possam configurar o tópico do Pub/Sub ao instalar a extensão, adicione um novo parâmetro ao arquivo extension.yaml e faça referência ao parâmetro na declaração resource da função:

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

Uma função acionada pelo Realtime Database é executada quando um caminho correspondente a um padrão especificado é criado, atualizado ou excluído.

Consulte Gatilhos do Realtime Database na documentação do Cloud Functions para informações sobre como escrever funções acionadas pelo RTDB.

Definição da função (apenas 1ª geração)

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

Declaração de recursos (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: ...

A tabela a seguir mostra como especificar cada um dos tipos de evento de Cloud Firestore compatíveis:

Gatilho de evento Cloud Functions eventType Descrição
onCreate() providers/google.firebase.database/eventTypes/ref.create Dados criados
onDelete() providers/google.firebase.database/eventTypes/ref.delete Dados excluídos
onUpdate() providers/google.firebase.database/eventTypes/ref.update Dados atualizados
onWrite() providers/google.firebase.database/eventTypes/ref.write Dados criados, excluídos ou atualizados

Se você quiser que os usuários possam configurar o caminho a ser observado ao instalar a extensão, adicione um novo parâmetro ao arquivo extension.yaml e faça referência ao parâmetro na declaração resource da função:

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

Uma função acionada pelo recurso Configuração remota é executada quando o modelo de parâmetro de um projeto é atualizado.

Consulte Gatilhos do recurso Configuração remota na documentação do Cloud Functions para informações sobre como escrever funções acionadas pela Configuração remota.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (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

Uma função acionada pelo Cloud Storage é executada quando um objeto é criado, arquivado ou excluído ou quando os metadados dele são alterados.

Consulte Gatilhos do Cloud Storage na documentação do Cloud Functions para sobre como escrever funções acionadas pelo Storage.

Definição da função (apenas 1ª geração)

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

Declaração de recursos (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: ...

A tabela a seguir mostra como especificar cada um dos tipos de evento de Cloud Storage compatíveis:

Gatilho de evento Cloud Functions eventType Descrição
onFinalize() google.storage.object.finalize Objeto criado
onMetadataUpdate() google.storage.object.metadataUpdate Metadados de objetos atualizados
onArchive() google.storage.object.archive O objeto foi arquivado
onDelete() google.storage.object.delete Objeto excluído

Se você quiser que os usuários possam configurar o bucket de armazenamento quando instalarem sua extensão, adicione um novo parâmetro ao arquivo extension.yaml e referencie o parâmetro na declaração resource da função:

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

Uma função acionada pelo Test Lab é executada quando uma matriz de teste termina os testes.

Consulte Gatilhos do Firebase Test Lab na documentação do Cloud Functions para informações sobre como escrever funções acionadas pelo Test Lab.

Definição da função (apenas 1ª geração)

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

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

Declaração de recursos (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: ...

Gatilhos de alertas Crashlytics

Uma função acionada por Crashlytics é executada quando Crashlytics publica um alerta.

Consulte Gatilhos de alertas do Firebase na documentação do Cloud Functions para informações sobre como escrever funções acionadas por alertas.

Definição da função (somente 2ª geração)

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

Declaração de recursos (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: ...

Você pode usar os seguintes valores para alerttype

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

Gatilhos de alertas Performance Monitoring

Uma função acionada por Performance Monitoring é executada quando Performance Monitoring publica um alerta.

Consulte Gatilhos de alertas do Firebase na documentação do Cloud Functions para informações sobre como escrever funções acionadas por alertas.

Definição da função (somente 2ª geração)

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

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

Declaração de recursos (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: ...

Gatilhos de alertas App Distribution

Uma função acionada por App Distribution é executada quando App Distribution publica um alerta.

Consulte Gatilhos de alertas do Firebase na documentação do Cloud Functions para informações sobre como escrever funções acionadas por alertas.

Definição da função (somente 2ª geração)

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

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

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

Declaração de recursos (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: ...

Você pode usar os seguintes valores para alerttype

  • appDistribution.newTesterIosDevice
  • appDistribution.inAppFeedback

Acionadores de eventos personalizados (Eventarc)

Uma função acionada pelo Eventarc é executada quando um tipo de evento específico é publicado em um canal específico.

Consulte Criar e processar acionadores de eventos personalizados na documentação do Cloud Functions para informações sobre como escrever funções acionadas pelo Eventarc.

Também é possível publicar eventos usando suas extensões para oferecer aos usuários uma maneira de inserir lógica personalizada em sua extensão. Consulte Usar lógica personalizada fornecida pelo desenvolvedor em uma extensão.

Definição da função (somente 2ª geração)

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

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

Declaração de recursos (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: ...

O canal precisa existir quando sua extensão estiver instalada. Por exemplo, se você depende de eventos personalizados de outra extensão que cria o canal, instrua seus usuários a instalar essa extensão primeiro.

O exemplo acima criaria um acionador de evento personalizado para o canal "padrão" do Firebase na região us-central1. Você pode personalizar o nome e a região do canal usando parâmetros. Por exemplo:


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}