Associações para Funções Duráveis (Azure Functions)

  • Artigo

A extensão Durable Functions introduz três novas associações de gatilho que controlam a execução de funções de orquestrador, entidade e atividade. Ela também introduz uma associação de saída que atua como um cliente para o runtime das Funções Duráveis.

Certifique-se de escolher sua linguagem de desenvolvimento do Durable Functions na parte superior do artigo.

Importante

Este artigo dá suporte a modelos de programação do Python v1 e Python v2 para Durable Functions.

Modelo de programação do Python v2

O Durable Functions tem suporte no novo modelo de programação do Python v2. Para usar o modelo v2, você deve instalar o SDK do Durable Functions, que é o pacote PyPI azure-functions-durable, versão 1.2.2 ou uma versão posterior. Você também deve verificar host.json para garantir que o aplicativo está fazendo referência aos Pacotes de Extensão da versão 4.x, para usar o modelo v2 com o Durable Functions.

É possível enviar comentários e sugestões no repositório do SDK do Durable Functions para Python.

Gatilho de orquestração

O gatilho de orquestração lhe permite criar funções de orquestrador duráveis. Esse gatilho é executado quando uma nova instância de orquestração é agendada e quando uma instância de orquestração existente recebe um evento. Exemplos de eventos que podem disparar as funções de orquestrador incluem expirações de temporizador durável, respostas de função de atividade e eventos gerados por clientes externos.

Quando você cria funções no .NET, o gatilho de orquestração é configurado usando o atributo .NET OrchestrationTriggerAttribute.

Para Java, a anotação @DurableOrchestrationTrigger é usada para configurar o gatilho de orquestração.

Quando você escreve funções de orquestrador, o gatilho de orquestração é definido pelo seguinte objeto JSON na matriz bindings do arquivo function.json:

{
    "name": "<Name of input parameter in function signature>",
    "orchestration": "<Optional - name of the orchestration>",
    "type": "orchestrationTrigger",
    "direction": "in"
}
  • orchestration é o nome da orquestração que os clientes devem usar quando quiserem iniciar novas instâncias dessa função de orquestrador. Essa propriedade é opcional. Se não for especificada, o nome da função será usado.

O Azure Functions dá suporte a dois modelos de programação do Python. A maneira como você define um gatilho de orquestração depende do modelo de programação escolhido.

O modelo de programação do Python v2 permite definir um gatilho de orquestração usando o decorador orchestration_trigger diretamente no código de função do Python.

No modelo v2, os gatilhos e associações do Durable Functions são acessados de uma instância do DFApp, que é uma subclasse do FunctionApp que exporta adicionalmente decoradores específicos do Durable Functions.

Internamente, essa associação de gatilho sonda o repositório durável configurado para novos eventos de orquestração, como eventos de início de orquestração, de expiração de temporizador durável, de resposta de função de atividade e externos gerados por outras funções.

Comportamento do gatilho

Veja algumas observações sobre o gatilho de orquestração:

  • Threading único – um único thread dispatcher é usado para toda a execução de função de orquestrador em uma única instância de host. Por esse motivo, é importante garantir que o código da função de orquestrador seja eficiente e não execute nenhuma E/S. Também é importante garantir que esse thread não faça nenhum trabalho assíncrono, exceto ao aguardar tipos de tarefas específicas das Funções Duráveis.
  • Manipulação de mensagens suspeitas – não há suporte para mensagens suspeitas nos gatilhos de orquestração.
  • Visibilidade da mensagem – as mensagens do gatilho de orquestração são removidas da fila e mantidas invisíveis por uma duração configurável. A visibilidade dessas mensagens é renovada automaticamente, desde que o aplicativo de funções esteja em execução e íntegro.
  • Valores retornados – os valores retornados são serializados em JSON e são persistidos na tabela de histórico de orquestração no Armazenamento de Tabelas do Azure. Esse valores retornados podem ser consultados pela associação do cliente de orquestração, descrita posteriormente.

Aviso

Funções de orquestrador nunca devem usar nenhuma associação de entrada ou saída que não seja a associação do gatilho de orquestração. Fazer isso tem o potencial de causar problemas com a extensão de Tarefa Durável, pois essas associações podem não cumprir as regras de E/S e de thread único. Se você quiser usar outras associações, adicione-as a uma função de atividade chamada a partir da sua função de orquestrador. Para saber mais sobre restrições de codificação para funções de orquestrador, confira a documentação Restrições de código de funções de orquestrador.

Aviso

As funções de orquestrador nunca devem ser declaradas como async.

Uso de gatilho

A associação de gatilho de orquestração dá suporte a entradas e saídas. Estas são algumas coisas que você precisa saber sobre a manipulação de entradas e saídas:

  • entradas – gatilhos de orquestração podem ser invocados com entradas, que são acessados por meio do objeto de entrada de contexto. Todas as entradas devem ser serializáveis em JSON.
  • saídas – gatilhos de orquestração dão suporte a valores de saída, bem como entradas. O valor retornado da função é usado para atribuir o valor de saída e deve ser serializável em JSON.

Exemplo de gatilho

O código de exemplo a seguir mostra como a função de orquestrador "Olá, Mundo" mais simples pode ser. Observe que este orquestrador de exemplo não faz o agendamento de nenhuma tarefa.

O atributo específico usado para definir o gatilho depende se você está executando suas funções C# em processo ou em um processo de trabalho isolado.

[FunctionName("HelloWorld")]
public static string Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string name = context.GetInput<string>();
    return $"Hello {name}!";
}

Observação

O código anterior é para Durable Functions 2.x. No Durable Functions 1.x, use DurableOrchestrationContext em vez de IDurableOrchestrationContext. Para obter mais informações sobre as diferenças entre versões, confira o artigo Versões do Durable Functions.

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    const name = context.df.getInput();
    return `Hello ${name}!`;
});

Observação

A biblioteca durable-functions cuida da chamada do método context.done síncrono quando a função do gerador é encerrada.

import azure.functions as func
import azure.durable_functions as df

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.orchestration_trigger(context_name="context")
def my_orchestrator(context):
    result = yield context.call_activity("Hello", "Tokyo")
    return result

param($Context)

$InputData = $Context.Input
$InputData

@FunctionName("HelloWorldOrchestration")
public String helloWorldOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    return String.format("Hello %s!", ctx.getInput(String.class));
}

A maioria das funções de orquestrador chamam funções de atividade, sendo assim, este é um exemplo de "Olá, Mundo" que demonstra como chamar uma função de atividade:

[FunctionName("HelloWorld")]
public static async Task<string> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string name = context.GetInput<string>();
    string result = await context.CallActivityAsync<string>("SayHello", name);
    return result;
}

Observação

O código anterior é para Durable Functions 2.x. No Durable Functions 1.x, use DurableOrchestrationContext em vez de IDurableOrchestrationContext. Para obter mais informações sobre as diferenças entre versões, confira o artigo Versões do Durable Functions.

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    const name = context.df.getInput();
    const result = yield context.df.callActivity("SayHello", name);
    return result;
});

@FunctionName("HelloWorld")
public String helloWorldOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String input = ctx.getInput(String.class);
    String result = ctx.callActivity("SayHello", input, String.class).await();
    return result;
}

Gatilho de atividade

O gatilho de atividade lhe permite criar funções que são chamadas por funções de orquestrador, conhecidas como funções de atividade.

O gatilho de atividade será configurado usando o atributo .NET ActivityTriggerAttribute.

O gatilho de atividade é configurado usando a anotação @DurableActivityTrigger.

O gatilho de atividade é definido pelo seguinte objeto JSON na matriz bindings do function.json:

{
    "name": "<Name of input parameter in function signature>",
    "activity": "<Optional - name of the activity>",
    "type": "activityTrigger",
    "direction": "in"
}
  • activity é o nome da atividade. Esse valor é o nome que as funções de orquestrador usam para invocar esta função de atividade. Essa propriedade é opcional. Se não for especificada, o nome da função será usado.

A maneira como você define um gatilho de atividade depende do modelo de programação escolhido.

Usando o decorador activity_trigger diretamente no código de função do Python.

Internamente, essa associação de gatilho sonda o repositório durável configurado para novos eventos de execução de atividade.

Comportamento do gatilho

Veja algumas observações sobre o gatilho de atividade:

  • Threading – diferente do gatilho de orquestração, os gatilhos de atividade não têm restrições quanto a threading ou E/S. Eles podem ser tratados como funções regulares.
  • Manipulação de mensagens suspeitas – não há suporte para mensagens suspeitas nos gatilhos de atividade.
  • Visibilidade da mensagem – as mensagens do gatilho de atividade são removidas da fila e mantidas invisíveis por uma duração configurável. A visibilidade dessas mensagens é renovada automaticamente, desde que o aplicativo de funções esteja em execução e íntegro.
  • Valores retornados – os valores retornados são serializados em JSON e são persistidos no repositório durável configurado.

Uso de gatilho

A associação de gatilho de atividade dá suporte a entradas e saídas, assim como no caso do gatilho de orquestração. Estas são algumas coisas que você precisa saber sobre a manipulação de entradas e saídas:

  • entradas – os gatilhos de atividade podem ser invocados com entradas de uma função de orquestrador. Todas as entradas devem ser serializáveis em JSON.
  • saídas – Funções de atividade dão suporte a valores de saída, bem como entradas. O valor retornado da função é usado para atribuir o valor de saída e deve ser serializável em JSON.
  • metadados – funções de atividade .NET podem ser associadas a um parâmetro string instanceId para obter a ID da instância da orquestração de chamada.

Exemplo de gatilho

O código de exemplo a seguir mostra a aparência de uma função de atividade SayHello simples.

[FunctionName("SayHello")]
public static string SayHello([ActivityTrigger] IDurableActivityContext helloContext)
{
    string name = helloContext.GetInput<string>();
    return $"Hello {name}!";
}

O tipo de parâmetro padrão para a associação .NET ActivityTriggerAttribute é IDurableActivityContext (ou DurableActivityContext para Durable Functions v1). No entanto, os gatilhos de atividade .NET também dão suporte à associação direta com tipos serializáveis em JSON (incluindo tipos primitivos), de modo que a mesma função poderia ser simplificada da seguinte forma:

[FunctionName("SayHello")]
public static string SayHello([ActivityTrigger] string name)
{
    return $"Hello {name}!";
}

module.exports = async function(context) {
    return `Hello ${context.bindings.name}!`;
};

Associações de JavaScript também podem ser passadas como parâmetros adicionais para que a mesma função possa ser simplificada da seguinte maneira:

module.exports = async function(context, name) {
    return `Hello ${name}!`;
};

import azure.functions as func
import azure.durable_functions as df

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.activity_trigger(input_name="myInput")
def my_activity(myInput: str):
    return "Hello " + myInput

param($name)

"Hello $name!"

@FunctionName("SayHello")
public String sayHello(@DurableActivityTrigger(name = "name") String name) {
    return String.format("Hello %s!", name);
}

Como usar associações de entrada e saída

Você pode usar associações de entrada e saída regulares, além da associação de gatilho de atividade.

Por exemplo, você pode pegar a entrada da associação de atividade e enviar uma mensagem para um Hub de Eventos usando a associação de saída dos Hubs de Eventos:

{
  "bindings": [
    {
      "name": "message",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "eventHub",
      "name": "outputEventHubMessage",
      "connection": "EventhubConnectionSetting",
      "eventHubName": "eh_messages",
      "direction": "out"
  }
  ]
}

module.exports = async function (context) {
    context.bindings.outputEventHubMessage = context.bindings.message;
};

Cliente de orquestração

A associação do cliente de orquestração permite que você escreva funções que interagem com funções de orquestrador. Essas funções são normalmente chamadas de funções de cliente. Por exemplo, você pode atuar em instâncias de orquestração das maneiras a seguir:

  • Iniciá-las.
  • Consultar seu status.
  • Encerrá-las.
  • Enviar eventos a elas durante sua execução.
  • Limpar o histórico de instância.

Você pode se associar ao cliente de orquestração usando o atributo DurableClientAttribute (OrchestrationClientAttribute no Durable Functions v1.x).

Você pode se associar ao cliente de orquestração usando a anotação @DurableClientInput.

O gatilho de cliente durável é definido pelo seguinte objeto JSON na matriz bindings do function.json:

{
    "name": "<Name of input parameter in function signature>",
    "taskHub": "<Optional - name of the task hub>",
    "connectionName": "<Optional - name of the connection string app setting>",
    "type": "orchestrationClient",
    "direction": "in"
}
  • taskHub – usado em cenários em que vários aplicativos de funções compartilham a mesma conta de armazenamento, mas precisam ser isolados uns dos outros. Se não for especificado, o valor padrão de host.json será usado. Esse valor deve corresponder ao valor usado pelas funções de orquestrador de destino.
  • connectionName – O nome de uma configuração de aplicativo que contém uma cadeia de conexão de armazenamento. A conta de armazenamento representada por essa cadeia de conexão deve ser a mesma usada pelas funções de orquestrador de destino. Se não for especificada, a cadeia de conexão da conta de armazenamento padrão do aplicativo de funções será usada.

Observação

Na maioria dos casos, é recomendável omitir essas propriedades e contar com o comportamento padrão.

A maneira como você define um gatilho de cliente durável depende do modelo de programação escolhido.

Usando o decorador durable_client_input diretamente no código de função do Python.

Uso do cliente

Normalmente você se associa a IDurableClient (DurableOrchestrationClient em Durable Functions v1.x), que oferece acesso completo a todas as APIs de orquestração de cliente compatíveis com o Durable Functions.

Normalmente, você se associa à classe DurableClientContext.

Você deve usar o SDK específico da linguagem para obter acesso a um objeto do cliente.

Veja um exemplo de função disparada em fila que é iniciada com uma orquestração "Olá, Mundo".

[FunctionName("QueueStart")]
public static Task Run(
    [QueueTrigger("durable-function-trigger")] string input,
    [DurableClient] IDurableOrchestrationClient starter)
{
    // Orchestration input comes from the queue message content.
    return starter.StartNewAsync<string>("HelloWorld", input);
}

Observação

O código C# anterior é para Durable Functions 2.x. Para o Durable Functions 1.x, você deve usar o atributo OrchestrationClient em vez do atributo DurableClient, e deve usar o tipo de parâmetro DurableOrchestrationClient em vez de IDurableOrchestrationClient. Para obter mais informações sobre as diferenças entre versões, confira o artigo Versões do Durable Functions.

function.json

{
  "bindings": [
    {
      "name": "input",
      "type": "queueTrigger",
      "queueName": "durable-function-trigger",
      "direction": "in"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ]
}

index.js

const df = require("durable-functions");

module.exports = async function (context) {
    const client = df.getClient(context);
    return instanceId = await client.startNew("HelloWorld", undefined, context.bindings.input);
};

run.ps1

param([string] $input, $TriggerMetadata)

$InstanceId = Start-DurableOrchestration -FunctionName $FunctionName -Input $input

import azure.functions as func
import azure.durable_functions as df

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.route(route="orchestrators/{functionName}")
@myApp.durable_client_input(client_name="client")
async def durable_trigger(req: func.HttpRequest, client):
    function_name = req.route_params.get('functionName')
    instance_id = await client.start_new(function_name)
    response = client.create_check_status_response(req, instance_id)
    return response

function.json

{
  "bindings": [
    {
      "name": "input",
      "type": "queueTrigger",
      "queueName": "durable-function-trigger",
      "direction": "in"
    },
    {
      "name": "starter",
      "type": "durableClient",
      "direction": "in"
    }
  ]
}

run.ps1

param([string]$InputData, $TriggerMetadata)

$InstanceId = Start-DurableOrchestration -FunctionName 'HelloWorld' -Input $InputData

@FunctionName("QueueStart")
public void queueStart(
        @QueueTrigger(name = "input", queueName = "durable-function-trigger", connection = "Storage") String input,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    // Orchestration input comes from the queue message content.
    durableContext.getClient().scheduleNewOrchestrationInstance("HelloWorld", input);
}

Mais detalhes sobre como iniciar instâncias podem ser encontrados em Gerenciamento de instâncias.

Gatilho de entidade

Os gatilhos de entidade permitem que você crie funções de entidade. Esse gatilho dá suporte ao processamento de eventos para uma instância de entidade específica.

Observação

Os gatilhos de entidade estão disponíveis a partir do Durable Functions 2.x.

Internamente, essa associação de gatilho sonda o repositório durável configurado para novas operações de entidade que precisam ser executadas.

O gatilho de entidade será configurado usando o atributo .NET EntityTriggerAttribute.

O gatilho de entidade é definido pelo seguinte objeto JSON na matriz bindings do function.json:

{
    "name": "<Name of input parameter in function signature>",
    "entityName": "<Optional - name of the entity>",
    "type": "entityTrigger",
    "direction": "in"
}

Por padrão, o nome da entidade é o nome da função.

Observação

Os gatilhos de entidade ainda não têm suporte para Java.

A maneira como você define um gatilho de entidade depende do modelo de programação escolhido.

Usando o decorador entity_trigger diretamente no código de função do Python.

Comportamento do gatilho

Veja algumas observações sobre o gatilho de entidade:

  • Thread único: um único thread de dispatcher é usado para processar operações para uma entidade específica. Se várias mensagens forem enviadas a uma única entidade de uma vez, as operações serão processadas uma por vez.
  • Manipulação de mensagens suspeitas – não há suporte para mensagens suspeitas nos gatilhos de entidade.
  • Visibilidade da mensagem – as mensagens do gatilho de entidade são removidas da fila e mantidas invisíveis por uma duração configurável. A visibilidade dessas mensagens é renovada automaticamente, desde que o aplicativo de funções esteja em execução e íntegro.
  • Valores de retorno – as funções de entidade não dão suporte a valores de retorno. Há APIs específicas que podem ser usadas para salvar o estado ou valores passar de volta para orquestrações.

Qualquer alteração de estado feita em uma entidade durante sua execução será persistida automaticamente após a conclusão da execução.

Para saber mais e obter exemplos sobre como definir e interagir com gatilhos de entidade, confira a documentação de Entidades duráveis.

Cliente de entidade

A associação de cliente de entidade permite que você dispare funções de entidade de forma assíncrona. Essas funções são podem ser chamadas de funções de cliente.

Você pode se associar ao cliente de entidade usando o atributo .NET DurableClientAttribute em funções de biblioteca de classes do .NET.

Observação

O [DurableClientAttribute] também pode ser usado para associar ao cliente de orquestração.

O cliente de entidade é definido pelo seguinte objeto JSON na matriz bindings do function.json:

{
    "name": "<Name of input parameter in function signature>",
    "taskHub": "<Optional - name of the task hub>",
    "connectionName": "<Optional - name of the connection string app setting>",
    "type": "durableClient",
    "direction": "in"
}
  • taskHub – usado em cenários em que vários aplicativos de funções compartilham a mesma conta de armazenamento, mas precisam ser isolados uns dos outros. Se não for especificado, o valor padrão de host.json será usado. Esse valor deve corresponder ao valor usado pelas funções de entidade de destino.
  • connectionName – O nome de uma configuração de aplicativo que contém uma cadeia de conexão de armazenamento. A conta de armazenamento representada por essa cadeia de conexão deve ser a mesma usada pelas funções de entidade de destino. Se não for especificada, a cadeia de conexão da conta de armazenamento padrão do aplicativo de funções será usada.

Observação

Na maioria dos casos, é recomendável omitir propriedades opcionais e contar com o comportamento padrão.

A maneira como você define um cliente de entidade depende do modelo de programação escolhido.

Usando o decorador durable_client_input diretamente no código de função do Python.

Observação

Os clientes de entidade ainda não têm suporte para Java.

Para saber mais e obter exemplos sobre como interagir com entidade como um cliente, confira a documentação de Entidades Duráveis.

configurações de host.json

Definições de configuração para Funções Duráveis.

Observação

Todas as versões principais das Durable Functions são compatíveis com todas as versões do Azure Functions Runtime. No entanto, o esquema da configuração host.json é ligeiramente diferente dependendo da versão do Azure Functions Runtime e da versão da extensão das Durable Functions que você usa. Os exemplos a seguir são referentes ao uso com o Azure Functions 2.0 e 3.0. Em ambos os exemplos, se você estiver usando o Azure Functions 1.0, as configurações disponíveis serão as mesmas, mas a seção "durableTask" do host.json deverá estar na raiz da configuração host.json, em vez de como um campo em "extensões".

{
 "extensions": {
  "durableTask": {
    "hubName": "MyTaskHub",
    "storageProvider": {
      "connectionStringName": "AzureWebJobsStorage",
      "controlQueueBatchSize": 32,
      "controlQueueBufferThreshold": 256,
      "controlQueueVisibilityTimeout": "00:05:00",
      "maxQueuePollingInterval": "00:00:30",
      "partitionCount": 4,
      "trackingStoreConnectionStringName": "TrackingStorage",
      "trackingStoreNamePrefix": "DurableTask",
      "useLegacyPartitionManagement": true,
      "useTablePartitionManagement": false,
      "workItemQueueVisibilityTimeout": "00:05:00",
    },
    "tracing": {
      "traceInputsAndOutputs": false,
      "traceReplayEvents": false,
    },
    "notifications": {
      "eventGrid": {
        "topicEndpoint": "https://topic_name.westus2-1.eventgrid.azure.net/api/events",
        "keySettingName": "EventGridKey",
        "publishRetryCount": 3,
        "publishRetryInterval": "00:00:30",
        "publishEventTypes": [
          "Started",
          "Completed",
          "Failed",
          "Terminated"
        ]
      }
    },
    "maxConcurrentActivityFunctions": 10,
    "maxConcurrentOrchestratorFunctions": 10,
    "extendedSessionsEnabled": false,
    "extendedSessionIdleTimeoutInSeconds": 30,
    "useAppLease": true,
    "useGracefulShutdown": false,
    "maxEntityOperationBatchSize": 50,
    "storeInputsInOrchestrationHistory": false
  }
 }
}

Nomes de hubs de tarefas devem começar com uma letra e devem ser compostos somente por letras e números. Se não for especificado, o nome padrão do hub de tarefas para um aplicativo de função será TestHubName. Para obter mais informações, consulte Hubs de tarefas.

Propriedade Padrão Descrição
hubName TestHubName (DurableFunctionsHub se estiver usando o Durable Functions 1.x) Nomes alternativos para hub de tarefas podem ser usados para isolar vários aplicativos de Funções Duráveis uns dos outros, mesmo se eles estiverem usando o mesmo back-end de armazenamento.
controlQueueBatchSize 32 O número de mensagens para efetuar pull da fila de controle por vez.
controlQueueBufferThreshold Plano de consumo para Python: 32
Plano de consumo para JavaScript e C#: 128
Plano Dedicado/Premium: 256		 O número de mensagens de fila de controle que podem ser armazenadas em buffer na memória por vez. Nesse ponto, o dispatcher aguardará antes de retirar da fila qualquer mensagem adicional.
partitionCount 4 A contagem de partição para a fila de controle. Pode ser um número inteiro positivo entre 1 e 16.
controlQueueVisibilityTimeout 5 minutos O limite de tempo de visibilidade das mensagens de remoção da fila de controle.
workItemQueueVisibilityTimeout 5 minutos O limite de tempo de visibilidade das mensagens de remoção da fila de item de trabalho.
maxConcurrentActivityFunctions Plano de Consumo: 10
Plano Dedicado/Premium: dez vezes o número de processadores do computador atual		 O número máximo de funções de atividade que podem ser processadas simultaneamente em uma única instância de host.
maxConcurrentOrchestratorFunctions Plano de Consumo: 5
Plano Dedicado/Premium: dez vezes o número de processadores do computador atual		 O número máximo de funções do orquestrador que podem ser processadas simultaneamente em uma única instância do host.
maxQueuePollingInterval 30 segundos O intervalo de sondagem da fila de item de trabalho e de controle máximo no formato hh:mm:ss. Valores mais altos podem resultar em latências de processamento de mensagens mais altas. Valores mais baixos podem resultar em custos de armazenamento maiores devido a um maior número de transações de armazenamento.
connectionName (2.7.0 e posterior)
connectionStringName (2.x)
azureStorageConnectionStringName (1.x)		 AzureWebJobsStorage O nome de uma configuração de um aplicativo ou de uma coleção de configurações que especifica como se conectar aos recursos subjacentes do Armazenamento do Azure. Quando é informada uma configuração de aplicativo único, é necessário que ela seja uma cadeia de conexão do Armazenamento do Azure.
trackingStoreConnectionName (2.7.0 e posterior)
trackingStoreConnectionStringName		 O nome de uma configuração de aplicativo ou de uma coleção de configurações que especifica como se conectar às tabelas História e Instâncias. Quando é informada uma configuração de aplicativo único, é necessário que ela seja uma cadeia de conexão do Armazenamento do Azure. Se não for especificado, a conexão connectionStringName (Durable 2.x) ou azureStorageConnectionStringName (Durable 1.x) será usada.
trackingStoreNamePrefix O prefixo a ser usado para as tabelas Histórico e Instâncias quando trackingStoreConnectionStringName for especificado. Se não estiver definido, o valor de prefixo padrão será DurableTask. Se trackingStoreConnectionStringName não for especificado, as tabelas Histórico e Instâncias usarão o valor hubName como o prefixo e qualquer configuração de trackingStoreNamePrefix será ignorada.
traceInputsAndOutputs false Um valor que indica se as entradas e saídas de chamadas de função sertão rastreadas. O comportamento padrão durante o rastreamento de eventos de execução de função é incluir o número de bytes nas entradas e saídas serializadas para chamadas de função. Esse comportamento fornece um mínimo de informações sobre como são as entradas e saídas sem sobrecarregar os logs ou expor inadvertidamente informações confidenciais. A definição dessa propriedade como true faz com que o log de função padrão registre todo o conteúdo de entradas e saídas da função.
traceReplayEvents false Um valor que indica se é necessário gravar eventos de reprodução de orquestração para o Application Insights.
eventGridTopicEndpoint A URL de um ponto de extremidade de tópico personalizado da Grade de Eventos do Azure. Quando essa propriedade for definida, eventos de notificação de ciclo de vida de orquestração serão publicados para esse ponto de extremidade. Esta propriedade dá suporte à resolução de Configurações do Aplicativo.
eventGridKeySettingName O nome da configuração de aplicativo que contém a chave usada para autenticar com o tópico personalizado da Grade de Eventos do Azure em EventGridTopicEndpoint.
eventGridPublishRetryCount 0 O número de novas tentativas se a publicação no Tópico de Grade de Eventos falha.
eventGridPublishRetryInterval 5 minutos A Grade de Eventos publica o intervalo de repetição no formato hh:mm:ss.
eventGridPublishEventTypes Uma lista de tipos de eventos a serem publicados na Grade de Eventos. Se não for especificada, todos os tipos de evento serão publicados. Os valores permitidos incluem Started, Completed, Failed, Terminated.
useAppLease true Quando configurado como true, os aplicativos exigirão adquirir uma concessão de blob de nível de aplicativo antes de processar mensagens do hub de tarefas. Para obter mais informações, consulte a documentação recuperação de desastre e distribuição geográfica. Disponível a partir da v2.3.0.
useLegacyPartitionManagement false Quando definido como false, ele usa um algoritmo de gerenciamento de partição que reduz a possibilidade de execução de função duplicada ao expandir. Disponível a partir da v2.3.0.
useTablePartitionManagement falso Quando definido como true, usa um algoritmo de gerenciamento de partição projetado para reduzir os custos das contas do Armazenamento do Microsoft Azure V2. Disponível a partir da v2.10.0. Esse recurso está atualmente em versão prévia e ainda não é compatível com o plano de Consumo.
useGracefulShutdown false (Versão Prévia) Habilite o desligamento normal para reduzir a chance de desligamentos de host falharem em execuções de função em processo.
maxEntityOperationBatchSize(2.6.1) Plano de consumo: 50
Plano Dedicado/Premium: 5000		 O número máximo de operações de entidade que são processadas como um lote. Se definido como 1, o lote será desabilitado e cada mensagem de operação será processada por uma invocação de função separada.
storeInputsInOrchestrationHistory falso Quando definido como true, informa a Estrutura de Tarefas Duráveis para salvar entradas de atividade na tabela de histórico. Isso permite a exibição de entradas de função de atividade ao consultar o histórico de orquestração.

Muitas dessas configurações servem para otimizar o desempenho. Para obter mais informações, consulte Desempenho e escala.

Próximas etapas

Referência de API HTTP interna para gerenciamento de instância