Gatilho de Hubs de Eventos do Azure para o Azure Functions

Este artigo explica como trabalhar com gatilho de Hubs de Eventos do Azure para o Azure Functions. O Azure Functions dá suporte a associações de gatilho e de saída para os Hubs de Eventos.

Para obter informações sobre a instalação e detalhes de configuração, confira a visão geral.

Use o gatilho de função para responder a um evento enviado para um fluxo de eventos do hub de eventos. Você precisa ter acesso de leitura ao hub de eventos subjacente para configurar o gatilho. Quando a função for disparada, a mensagem passada para a função será digitada como uma cadeia de caracteres.

As decisões de colocação em escala dos Hubs de Eventos para os planos Consumo e Premium são feitas por meio da Colocação em Escala Baseada em Destino. Para obter mais informações, consulte Colocação em Escala Baseada em Destino.

Para obter informações sobre como o Azure Functions responde a eventos enviados a um fluxo de eventos do hub de eventos usando gatilhos, consulte Integrar Hubs de Eventos com funções sem servidor no Azure.

Importante

Este artigo usa guias para dar suporte a várias versões do modelo de programação Node.js. O modelo v4 normalmente está disponível e foi projetado para oferecer uma experiência mais flexível e intuitiva para desenvolvedores de JavaScript e TypeScript. Para obter mais detalhes sobre como funciona o modelo v4, consulte o Guia do desenvolvedor do Node.js para o Azure Functions. Para saber mais sobre as diferenças entre os modelos v3 e a v4, consulte o Guia de migração.

O Azure Functions dá suporte a dois modelos de programação para Python. A maneira como você define suas associações depende do modelo de programação escolhido.

v2

O modelo de programação v2 do Python permite que você defina associações usando decoradores diretamente no código de função do Python. Para saber mais, confira o Guia do desenvolvedor do Python.

v1

O modelo de programação v1 do Python requer que você defina as associações em um arquivo function.json separado na pasta de funções. Para saber mais, confira o Guia do desenvolvedor do Python.

Este artigo dá suporte a ambos os modelos de programação.

Exemplo

Modelo de trabalho isolado

O exemplo a seguir mostra uma função C# que é disparada com base em um hub de eventos, em que a cadeia de caracteres de mensagem de entrada é gravada nos logs:

{
    private readonly ILogger<EventHubsFunction> _logger;

    public EventHubsFunction(ILogger<EventHubsFunction> logger)
    {
        _logger = logger;
    }

    [Function(nameof(EventHubFunction))]
    [FixedDelayRetry(5, "00:00:10")]
    [EventHubOutput("dest", Connection = "EventHubConnection")]
    public string EventHubFunction(
        [EventHubTrigger("src", Connection = "EventHubConnection")] string[] input,
        FunctionContext context)
    {
        _logger.LogInformation("First Event Hubs triggered message: {msg}", input[0]);

        var message = $"Output message created at {DateTime.Now}";
        return message;
    }

Modelo em processo

Importante

O suporte terminará para o modelo em processo em 10 de novembro de 2026. É altamente recomendável migrar seus aplicativos para o modelo de trabalho isolado para obter suporte completo.

O exemplo a seguir mostra uma função C# que registra o corpo da mensagem do gatilho dos Hubs de Eventos.

[FunctionName("EventHubTriggerCSharp")]
public void Run([EventHubTrigger("samples-workitems", Connection = "EventHubConnectionAppSetting")] string myEventHubMessage, ILogger log)
{
    log.LogInformation($"C# function triggered to process a message: {myEventHubMessage}");
}

Para obter acesso aos metadados no código da função, associe um objeto de EventData. Você também pode acessar as mesmas propriedades usando expressões de associação na assinatura do método. O exemplo a seguir mostra duas formas de obter os mesmos dados:

[FunctionName("EventHubTriggerCSharp")]
public void Run(
    [EventHubTrigger("samples-workitems", Connection = "EventHubConnectionAppSetting")] EventData myEventHubMessage,
    DateTime enqueuedTimeUtc,
    Int64 sequenceNumber,
    string offset,
    ILogger log)
{
    log.LogInformation($"Event: {Encoding.UTF8.GetString(myEventHubMessage.Body)}");
    // Metadata accessed by binding to EventData
    log.LogInformation($"EnqueuedTimeUtc={myEventHubMessage.SystemProperties.EnqueuedTimeUtc}");
    log.LogInformation($"SequenceNumber={myEventHubMessage.SystemProperties.SequenceNumber}");
    log.LogInformation($"Offset={myEventHubMessage.SystemProperties.Offset}");
    // Metadata accessed by using binding expressions in method parameters
    log.LogInformation($"EnqueuedTimeUtc={enqueuedTimeUtc}");
    log.LogInformation($"SequenceNumber={sequenceNumber}");
    log.LogInformation($"Offset={offset}");
}

Para receber eventos em um lote, faça string ou EventData uma matriz.

Observação

Ao receber em um lote, não é possível associar aos parâmetros do método, como no exemplo acima com DateTime enqueuedTimeUtc, e deve recebê-los de cada objeto EventData

[FunctionName("EventHubTriggerCSharp")]
public void Run([EventHubTrigger("samples-workitems", Connection = "EventHubConnectionAppSetting")] EventData[] eventHubMessages, ILogger log)
{
    foreach (var message in eventHubMessages)
    {
        log.LogInformation($"C# function triggered to process a message: {Encoding.UTF8.GetString(message.Body)}");
        log.LogInformation($"EnqueuedTimeUtc={message.SystemProperties.EnqueuedTimeUtc}");
    }
}

Modelo v4

O exemplo a seguir mostra uma função TypeScript do gatilho dos Hubs de Eventos. A função lê os metadados de evento e registra a mensagem.

import { app, InvocationContext } from '@azure/functions';

export async function eventHubTrigger1(message: unknown, context: InvocationContext): Promise<void> {
    context.log('Event hub function processed message:', message);
    context.log('EnqueuedTimeUtc =', context.triggerMetadata.enqueuedTimeUtc);
    context.log('SequenceNumber =', context.triggerMetadata.sequenceNumber);
    context.log('Offset =', context.triggerMetadata.offset);
}

app.eventHub('eventHubTrigger1', {
    connection: 'myEventHubReadConnectionAppSetting',
    eventHubName: 'MyEventHub',
    cardinality: 'one',
    handler: eventHubTrigger1,
});

Para receber eventos em um lote, defina cardinality como many, conforme mostrado no exemplo a seguir.

import { app, InvocationContext } from '@azure/functions';

export async function eventHubTrigger1(messages: unknown[], context: InvocationContext): Promise<void> {
    context.log(`Event hub function processed ${messages.length} messages`);
    for (let i = 0; i < messages.length; i++) {
        context.log('Event hub message:', messages[i]);
        context.log(`EnqueuedTimeUtc = ${context.triggerMetadata.enqueuedTimeUtcArray[i]}`);
        context.log(`SequenceNumber = ${context.triggerMetadata.sequenceNumberArray[i]}`);
        context.log(`Offset = ${context.triggerMetadata.offsetArray[i]}`);
    }
}

app.eventHub('eventHubTrigger1', {
    connection: 'myEventHubReadConnectionAppSetting',
    eventHubName: 'MyEventHub',
    cardinality: 'many',
    handler: eventHubTrigger1,
});

Modelo v3

As amostras de TypeScript não estão documentadas para o modelo v3.

Modelo v4

O exemplo a seguir mostra uma função JavaScript do gatilho dos Hubs de Eventos. A função lê os metadados de evento e registra a mensagem.

const { app } = require('@azure/functions');

app.eventHub('eventHubTrigger1', {
    connection: 'myEventHubReadConnectionAppSetting',
    eventHubName: 'MyEventHub',
    cardinality: 'one',
    handler: (message, context) => {
        context.log('Event hub function processed message:', message);
        context.log('EnqueuedTimeUtc =', context.triggerMetadata.enqueuedTimeUtc);
        context.log('SequenceNumber =', context.triggerMetadata.sequenceNumber);
        context.log('Offset =', context.triggerMetadata.offset);
    },
});

Para receber eventos em um lote, defina cardinality como many, conforme mostrado no exemplo a seguir.

const { app } = require('@azure/functions');

app.eventHub('eventHubTrigger1', {
    connection: 'myEventHubReadConnectionAppSetting',
    eventHubName: 'MyEventHub',
    cardinality: 'many',
    handler: (messages, context) => {
        context.log(`Event hub function processed ${messages.length} messages`);
        for (let i = 0; i < messages.length; i++) {
            context.log('Event hub message:', messages[i]);
            context.log(`EnqueuedTimeUtc = ${context.triggerMetadata.enqueuedTimeUtcArray[i]}`);
            context.log(`SequenceNumber = ${context.triggerMetadata.sequenceNumberArray[i]}`);
            context.log(`Offset = ${context.triggerMetadata.offsetArray[i]}`);
        }
    },
});

Modelo v3

O exemplo a seguir mostra uma associação de gatilho de Hubs de Eventos em um arquivo function.json e uma função JavaScript que usa a associação. A função lê os metadados de evento e registra a mensagem.

{
  "type": "eventHubTrigger",
  "name": "myEventHubMessage",
  "direction": "in",
  "eventHubName": "MyEventHub",
  "connection": "myEventHubReadConnectionAppSetting"
}

Aqui está o código JavaScript:

module.exports = function (context, myEventHubMessage) {
    context.log('Function triggered to process a message: ', myEventHubMessage);
    context.log('EnqueuedTimeUtc =', context.bindingData.enqueuedTimeUtc);
    context.log('SequenceNumber =', context.bindingData.sequenceNumber);
    context.log('Offset =', context.bindingData.offset);

    context.done();
};

Para receber eventos em um lote, defina cardinality para many no arquivo cardinality, conforme mostrado nos exemplos a seguir.

{
  "type": "eventHubTrigger",
  "name": "eventHubMessages",
  "direction": "in",
  "eventHubName": "MyEventHub",
  "cardinality": "many",
  "connection": "myEventHubReadConnectionAppSetting"
}

Aqui está o código JavaScript:

module.exports = function (context, eventHubMessages) {
    context.log(`JavaScript eventhub trigger function called for message array ${eventHubMessages}`);

    eventHubMessages.forEach((message, index) => {
        context.log(`Processed message ${message}`);
        context.log(`EnqueuedTimeUtc = ${context.bindingData.enqueuedTimeUtcArray[index]}`);
        context.log(`SequenceNumber = ${context.bindingData.sequenceNumberArray[index]}`);
        context.log(`Offset = ${context.bindingData.offsetArray[index]}`);
    });

    context.done();
};

Aqui está o código do PowerShell:

param($eventHubMessages, $TriggerMetadata)

Write-Host "PowerShell eventhub trigger function called for message array: $eventHubMessages"

$eventHubMessages | ForEach-Object { Write-Host "Processed message: $_" }

O exemplo a seguir mostra uma associação de acionador de Hubs de Eventos e uma função do Python que usa a associação. A função lê os metadados de evento e registra a mensagem. O exemplo depende se você usa o modelo de programação do Python v1 ou v2.

v2

import logging
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="EventHubTrigger1")
@app.event_hub_message_trigger(arg_name="myhub", 
                               event_hub_name="<EVENT_HUB_NAME>",
                               connection="<CONNECTION_SETTING>") 
def test_function(myhub: func.EventHubEvent):
    logging.info('Python EventHub trigger processed an event: %s',
                myhub.get_body().decode('utf-8'))

v1

Os exemplos a seguir mostram dados de associação de Hubs de eventos no function.json arquivo.

{
  "type": "eventHubTrigger",
  "name": "event",
  "direction": "in",
  "eventHubName": "MyEventHub",
  "connection": "myEventHubReadConnectionAppSetting"
}

Aqui está o código Python:

import logging
import azure.functions as func


def main(event: func.EventHubEvent):
    logging.info(f'Function triggered to process a message: {event.get_body().decode()}')
    logging.info(f'  EnqueuedTimeUtc = {event.enqueued_time}')
    logging.info(f'  SequenceNumber = {event.sequence_number}')
    logging.info(f'  Offset = {event.offset}')

    # Metadata
    for key in event.metadata:
        logging.info(f'Metadata: {key} = {event.metadata[key]}')

O exemplo a seguir mostra uma associação de gatilho de Hubs de Eventos que registra o corpo da mensagem do gatilho de Hubs de Eventos.

@FunctionName("ehprocessor")
public void eventHubProcessor(
  @EventHubTrigger(name = "msg",
                  eventHubName = "myeventhubname",
                  connection = "myconnvarname") String message,
       final ExecutionContext context )
       {
          context.getLogger().info(message);
 }

No biblioteca de runtime de funções Java, use a anotação EventHubTrigger em parâmetros cujo valor é derivado do hub de eventos. Parâmetros com essas anotações fazem com que a função seja executada quando um evento é recebido. Essa anotação pode ser usada com tipos nativos do Java, POJOs ou valores que permitem valor nulos usando Optional<T>.

O exemplo a seguir ilustra o uso extensivo de SystemProperties e outras opções de Associação para maior introspecção do Evento, além de fornecer um caminho BlobOutput bem formado que seja de data hierárquica.

package com.example;
import java.util.Map;
import java.time.ZonedDateTime;

import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;

/**
 * Azure Functions with Event Hub trigger.
 * and Blob Output using date in path along with message partition ID
 * and message sequence number from EventHub Trigger Properties
 */
public class EventHubReceiver {

    @FunctionName("EventHubReceiver")
    @StorageAccount("bloboutput")

    public void run(
            @EventHubTrigger(name = "message",
                eventHubName = "%eventhub%",
                consumerGroup = "%consumergroup%",
                connection = "eventhubconnection",
                cardinality = Cardinality.ONE)
            String message,

            final ExecutionContext context,

            @BindingName("Properties") Map<String, Object> properties,
            @BindingName("SystemProperties") Map<String, Object> systemProperties,
            @BindingName("PartitionContext") Map<String, Object> partitionContext,
            @BindingName("EnqueuedTimeUtc") Object enqueuedTimeUtc,

            @BlobOutput(
                name = "outputItem",
                path = "iotevents/{datetime:yy}/{datetime:MM}/{datetime:dd}/{datetime:HH}/" +
                       "{datetime:mm}/{PartitionContext.PartitionId}/{SystemProperties.SequenceNumber}.json")
            OutputBinding<String> outputItem) {

        var et = ZonedDateTime.parse(enqueuedTimeUtc + "Z"); // needed as the UTC time presented does not have a TZ
                                                             // indicator
        context.getLogger().info("Event hub message received: " + message + ", properties: " + properties);
        context.getLogger().info("Properties: " + properties);
        context.getLogger().info("System Properties: " + systemProperties);
        context.getLogger().info("partitionContext: " + partitionContext);
        context.getLogger().info("EnqueuedTimeUtc: " + et);

        outputItem.setValue(message);
    }
}

Atributos

As bibliotecas C# em processo e de processo de trabalho isolado usam atributos para configurar o gatilho. Em vez disso, o script C# usa um arquivo de configuração function.json, conforme descrito no guia do script C# .

Modelo de trabalho isolado

Use o EventHubTriggerAttribute para definir um gatilho em um hub de eventos, que é compatível com as propriedades a seguir.

Parâmetros	Descrição
EventHubName	O nome do hub de eventos. Quando o nome do hub de eventos também estiver presente na cadeia de conexão, esse valor substitui essa propriedade em runtime. Pode ser referenciado por meio das configurações de aplicativo, como %eventHubName%
ConsumerGroup	É uma propriedade opcional que define o grupo de consumidores usado para assinar eventos no hub. Quando omitido, o grupo de consumidores $Default será usado.
Conexão	O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Hubs de Eventos. Para saber mais, confira Conexões.

Modelo em processo

Em bibliotecas de classes C#, use o EventHubTriggerAttribute, que é compatível com as propriedades a seguir.

Parâmetros	Descrição
EventHubName	O nome do hub de eventos. Quando o nome do hub de eventos também estiver presente na cadeia de conexão, esse valor substitui essa propriedade em runtime. Pode ser referenciado por meio das configurações de aplicativo, como %eventHubName%
ConsumerGroup	É uma propriedade opcional que define o grupo de consumidores usado para assinar eventos no hub. Quando omitido, o grupo de consumidores $Default será usado.
Conexão	O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Hubs de Eventos. Para saber mais, confira Conexões.

Decoradores

Aplica-se somente ao modelo de programação v2 do Python.

Para funções do Python v2 definidas usando um decorador, as seguintes propriedades no event_hub_message_trigger:

Propriedade	DESCRIÇÃO
arg_name	O nome da variável que representa o item de evento no código de função.
event_hub_name	O nome do hub de eventos. Quando o nome do hub de eventos também estiver presente na cadeia de conexão, esse valor substitui essa propriedade em runtime.
connection	O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Hubs de Eventos. Confira a opção Conexões.

Para funções do Python definidas usando function.json, confira a seção Configuração.

Anotações

Na biblioteca de tempo de execução de funções Java, use a anotação EventHubTrigger, que oferece suporte às seguintes configurações:

• name
• dataType
• eventHubName
• connection
• cardinalidade
• consumerGroup

Configuração

Aplica-se apenas ao modelo de programação v1 do Python.

Modelo v4

A tabela a seguir explica as propriedades que você pode definir no objeto options transmitido para o método app.eventHub().

Propriedade	Descrição
eventHubName	O nome do hub de eventos. Quando o nome do hub de eventos também estiver presente na cadeia de conexão, esse valor substitui essa propriedade em runtime. Pode ser referenciado por meio das configurações de aplicativo do %eventHubName%
consumerGroup	É uma propriedade opcional que define o grupo de consumidores usado para assinar eventos no hub. Se omitido, o grupo de consumidores $Default será usado.
cardinalidade	Definido como many para habilitar o envio em lote. Se for omitida ou definida como one, uma mensagem será passada para a função.
connection	O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Hubs de Eventos. Confira a opção Conexões.

Modelo v3

A tabela a seguir explica as propriedades de configuração de associação que você define no arquivo function.json.

Propriedade	Descrição
tipo	Deve ser definido como eventHubTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direction	Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
name	O nome da variável que representa o item de evento no código de função.
eventHubName	O nome do hub de eventos. Quando o nome do hub de eventos também estiver presente na cadeia de conexão, esse valor substitui essa propriedade em runtime. Pode ser referenciado por meio das configurações de aplicativo do %eventHubName%
consumerGroup	É uma propriedade opcional que define o grupo de consumidores usado para assinar eventos no hub. Se omitido, o grupo de consumidores $Default será usado.
cardinalidade	Definido como many para habilitar o envio em lote. Se for omitida ou definida como one, uma mensagem será passada para a função.
connection	O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Hubs de Eventos. Confira a opção Conexões.

A tabela a seguir explica as propriedades de configuração de gatilho que você define no arquivo function.json, que difere segundo a versão de runtime.

Functions 2.x+

Propriedade function.json	Descrição
tipo	Deve ser definido como eventHubTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direction	Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
name	O nome da variável que representa o item de evento no código de função.
eventHubName	O nome do hub de eventos. Quando o nome do hub de eventos também estiver presente na cadeia de conexão, esse valor substitui essa propriedade em runtime. Pode ser referenciado por meio das configurações de aplicativo do %eventHubName%
consumerGroup	É uma propriedade opcional que define o grupo de consumidores usado para assinar eventos no hub. Se omitido, o grupo de consumidores $Default será usado.
cardinalidade	Definido como many para habilitar o envio em lote. Se for omitida ou definida como one, uma mensagem será passada para a função.
connection	O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Hubs de Eventos. Confira a opção Conexões.

Funções 1.x

Propriedade function.json	Descrição
tipo	Deve ser definido como eventHubTrigger. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
direction	Deve ser definido como in. Essa propriedade é definida automaticamente quando você cria o gatilho no portal do Azure.
name	O nome da variável que representa o item de evento no código de função.
path	O nome do hub de eventos. Quando o nome do hub de eventos também estiver presente na cadeia de conexão, esse valor substitui essa propriedade em runtime.
consumerGroup	É uma propriedade opcional que define o grupo de consumidores usado para assinar eventos no hub. Se omitido, o grupo de consumidores $Default será usado.
cardinalidade	Definido como many para habilitar o envio em lote. Se for omitida ou definida como one, uma mensagem será passada para a função.
connection	O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos Hubs de Eventos. Confira a opção Conexões.

Quando você estiver desenvolvendo localmente, adicione as configurações do aplicativo no arquivo local.settings.json na coleção Values.

Uso

Para saber mais sobre como o gatilho dos Hubs de Eventos e o gatilho do Hub IoT escalam, consulte Consumir Eventos com o Azure Functions.

Os tipos específicos com suporte pela associação de saída do Hubs de Eventos dependem da versão de runtime do Functions, da versão do pacote de extensão e da modalidade de C# usada.

Extensão v5.x+

As funções da biblioteca de classes C# em processo são compatíveis com os seguintes tipos:

• Azure.Messaging.EventHubs.EventData
• String
• Matriz de bytes
• Objeto CRL básico (POCO)

Essa versão do EventData remove o suporte do tipo Body herdado em favor do EventBody.

Extensão v3.x+

As funções da biblioteca de classes C# em processo são compatíveis com os seguintes tipos:

• Microsoft.Azure.EventHubs.EventData
• String
• Matriz de bytes
• Objeto CRL básico (POCO)

Extensão v5.x+

Quando você quiser que a função processe um único evento, o gatilho dos Hubs de Eventos pode ser associado aos seguintes tipos:

Type	Descrição
string	O evento como uma cadeia de caracteres. Use quando a mensagem for de texto simples.
byte[]	Os bytes do evento.
Tipos serializáveis JSON	Quando um evento contém dados JSON, o Functions tenta desserializar os dados JSON em um tipo de objeto CLR básico (POCO).
Azure.Messaging.EventHubs.EventData1	O objeto de evento. Se você estiver migrando de versões mais antigas dos SDKs dos Hubs de Eventos, observe que essa versão descarta o suporte para o tipo herdado Body em favor do EventBody.

Quando você deseja que a função processe um lote de eventos, o gatilho dos Hubs de Eventos pode se associar aos seguintes tipos:

Type	Descrição
string[]	Uma matriz de eventos do lote, como cadeias de caracteres. Cada entrada representa um evento.
EventData[] 1	Uma matriz de eventos do lote, como instâncias do Azure.Messaging.EventHubs.EventData. Cada entrada representa um evento.
T[] em que T é um tipo serializável por JSON 1	Uma matriz de eventos do lote, como instâncias de um tipo POCO personalizado. Cada entrada representa um evento.

¹ Para usar esses tipos, você precisa consultar asMicrosoft.Azure.Functions.Worker.Extensions.EventHubs 5.5.0 ou posterior e as dependências comuns para vinculações de dados do tipo SDK.

Extensão v3.x+

Exige que você defina um tipo personalizado ou use uma cadeia de caracteres. Opções adicionais estão disponíveis para a Extensão 5.x e superior.

O tipo de parâmetro pode ser um dos seguintes:

• Quaisquer tipos Java nativos, como int, String, byte[].
• Valores anuláveis usando Opcional.
• Qualquer tipo POJO.

Para saber mais, consulte a referência EventHubTrigger.

Metadados de evento

O gatilho dos Hubs de Evento fornece várias propriedades de metadados. As propriedades de metadados podem ser usadas como parte de expressões de associação em outras associações ou como parâmetros no seu código. As propriedades são provenientes da classe EventData.

Propriedade	Type	Descrição
PartitionContext	PartitionContext	A instância PartitionContext.
EnqueuedTimeUtc	DateTime	O tempo de enfileiramento no UTC.
Offset	string	O deslocamento dos dados em relação ao fluxo de partição do hub de eventos. O deslocamento é um marcador ou um identificador para um evento dentro do fluxo do Hubs de Eventos. O identificador é exclusivo dentro de uma partição do fluxo de Hubs de Eventos.
PartitionKey	string	A partição para os dados de evento deve ser enviada.
Properties	IDictionary<String,Object>	Propriedades do usuário dos dados do evento.
SequenceNumber	Int64	O número de sequência lógica do evento.
SystemProperties	IDictionary<String,Object>	Propriedades do sistema, incluindo dos dados do evento.

Consulte exemplos de código que usam essas propriedades neste artigo.

conexões

A propriedade connection é uma referência à configuração de ambiente que especifica como o aplicativo deve se conectar aos Hubs de Eventos. Ela pode especificar:

• O nome da configuração de um aplicativo contendo uma cadeia de conexão
• O nome de um prefixo compartilhado com várias configurações de aplicativo, definindo juntas uma conexão baseada em identidade.

Se o valor configurado for uma combinação exata para uma única configuração e um correspondência de prefixo para outras configurações, a correspondente exata será usada.

Cadeia de conexão

Para obter essa cadeia de conexão, clique no botão Informações de Conexão do namespace, não no próprio hub de eventos. A cadeia de conexão deve ser para um namespace dos Hubs de Eventos, não para o próprio hub de eventos.

Quando usada para gatilhos, a cadeia de conexão deve ter pelo menos permissões de "leitura" para ativar a função. Quando usada para associações de saída, a cadeia de conexão deve ter permissões de "enviar" para enviar mensagens para o fluxo de eventos.

Essa cadeia de conexão deve ser armazenada em uma configuração de aplicativo com um nome que corresponda ao valor especificado pela propriedade connection da configuração de associação.

Conexões baseadas em identidade

Caso esteja usando a versão 5.x ou superior da extensão, em vez de usar uma cadeia de conexão com um segredo, faça com que o aplicativo use uma identidade do Microsoft Entra. Para fazer isso, defina as configurações em um prefixo comum que mapeia para a propriedade connection na configuração de gatilho e de associação.

Nesse modo, a extensão exige as seguintes propriedades:

Propriedade	Modelo de variável de ambiente	Descrição	Valor de exemplo
Namespace totalmente qualificado	<CONNECTION_NAME_PREFIX>__fullyQualifiedNamespace	O namespace totalmente qualificado dos Hubs de Eventos.	myeventhubns.servicebus.windows.net

É possível definir propriedades adicionais para personalizar a conexão. Confira Propriedades comuns para conexões baseadas em identidade.

Observação

Ao usar a Configuração de Aplicativos do Azure ou o Key Vault para fornecer configurações para conexões de Identidade Gerenciada, os nomes de configuração devem usar um separador de chave válido, como : ou / no lugar de __ para garantir que os nomes sejam resolvidos corretamente.

Por exemplo, <CONNECTION_NAME_PREFIX>:fullyQualifiedNamespace.

Quando hospedadas no serviço de Azure Functions, as conexões baseadas em identidade usam uma identidade gerenciada. A identidade atribuída pelo sistema é usada por padrão, embora a identidade atribuída pelo usuário possa ser especificada com as propriedades credential e clientID. Observe que não há suporte para configurar uma identidade atribuída pelo usuário com uma ID de recurso. Quando executado em outros contextos, como desenvolvimento local, a identidade do desenvolvedor é usada, embora isso possa ser personalizado. Confira Desenvolvimento local com conexões baseadas em identidade.

Conceder permissão para a identidade

Qualquer identidade que esteja sendo usada deve ter permissões para executar as ações pretendidas. Para a maioria dos serviços do Azure, isso significa que será necessário atribuir uma função no Azure RBAC, usando as funções internas ou as personalizadas que fornecem essas permissões.

Importante

Algumas permissões que não são necessárias em todos os contextos podem ser expostas pelo serviço de destino. Sempre que possível, siga o princípio do privilégio mínimo, concedendo à identidade apenas os privilégios necessários. Por exemplo, se o aplicativo precisar apenas ser capaz de ler uma fonte de dados, use uma função que só tenha permissão de leitura. Seria inapropriado atribuir uma função que também permitisse a gravação nesse serviço, pois seria um excesso de permissões para uma operação de leitura. Da mesma forma, seria melhor garantir que a atribuição da função tivesse o escopo apenas sobre os recursos que precisam ser lidos.

Será necessário criar uma atribuição de função que forneça acesso ao seu hub de eventos em runtime. O escopo da atribuição de função deve ser para um namespace dos Hubs de Eventos, não para o próprio hub de eventos. Funções de gerenciamento como Proprietário não são suficientes. A tabela a seguir mostra as funções internas recomendadas ao usar a extensão dos Hubs de Eventos em operação normal. Seu aplicativo pode exigir permissões adicionais com base no código escrito por você.

Tipo de associação	Exemplo de funções internas
Gatilho	Receptor de Dados dos Hubs de Eventos do Azure, Proprietário dos Dados dos Hubs de Eventos do Azure
Associação de saída	Remetente de dados dos Hubs de Eventos do Azure

configurações de host.json

O arquivo host.json contém configurações que controlam o comportamento de gatilho dos Hubs de Eventos. Confira a seção Configurações de host.json para obter detalhes em relação às configurações disponíveis.

Próximas etapas

• Gravar eventos em um fluxo de eventos (Associação de saída)