Partilhar via

Ligações para funções duráveis (Azure Functions)

  • Artigo

A extensão Durable Functions introduz três ligações de gatilho que controlam a execução de funções de orquestrador, entidade e atividade. Ele também introduz uma ligação de saída que atua como um cliente para o tempo de execução de funções duráveis.

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

Importante

Este artigo suporta modelos de programação Python v1 e Python v2 para funções duráveis.

Modelo de programação Python v2

Durable Functions é suportado no novo modelo de programação Python v2. Para usar o modelo v2, você deve instalar o Durable Functions SDK, que é o pacote azure-functions-durablePyPI, versão 1.2.2 ou uma versão posterior. Você também deve verificar host.json se seu aplicativo está fazendo referência aos Pacotes de Extensão versão 4.x para usar o modelo v2 com Funções Duráveis.

Você pode fornecer comentários e sugestões no repositório Durable Functions SDK for Python.

Gatilho de orquestração

O gatilho de orquestração permite que você crie funções duráveis do orquestrador. 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 acionar funções do orquestrador incluem expirações duráveis do temporizador, respostas da 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 OrchestrationTriggerAttribute .NET.

Para Java, a @DurableOrchestrationTrigger anotação é 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 bindings matriz 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 desejam iniciar novas instâncias dessa função do orquestrador. Esta propriedade é opcional. Se não for especificado, o nome da função será usado.

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

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

No modelo v2, os gatilhos e ligações de Funções Duráveis são acessados a partir de uma instância de DFApp, que é uma subclasse que exporta adicionalmente decoradores específicos de FunctionApp Funções Duráveis.

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

Comportamento do acionador

Aqui estão algumas notas sobre o gatilho de orquestração:

  • Single-threading - Um único thread do dispatcher é usado para toda a execução da função do orchestrator em uma única instância de host. Por esse motivo, é importante garantir que o código de função do 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 quando estiver aguardando tipos de tarefas específicos de Funções Duráveis.
  • Tratamento de mensagens suspeitas - Não há suporte para mensagens suspeitas em gatilhos de orquestração.
  • Visibilidade da mensagem - As mensagens de gatilho de orquestração são retiradas da fila e mantidas invisíveis por uma duração configurável. A visibilidade dessas mensagens é renovada automaticamente desde que o aplicativo de função esteja em execução e íntegro.
  • Valores de retorno - Os valores de retorno são serializados para JSON e persistem na tabela de histórico de orquestração no armazenamento de tabela do Azure. Esses valores de retorno podem ser consultados pela associação do cliente de orquestração, descrita posteriormente.

Aviso

As funções do orquestrador nunca devem usar nenhuma ligação de entrada ou saída além da ligação do gatilho de orquestração. Isso tem o potencial de causar problemas com a extensão Durable Task porque essas ligações podem não obedecer às regras de threading único e E/S. 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 obter mais informações sobre restrições de codificação para funções do orchestrator, consulte a documentação de restrições de código de função do Orchestrator.

Aviso

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

Acionar o uso

A ligação do gatilho de orquestração suporta entradas e saídas. Aqui estão algumas coisas a saber sobre o tratamento de entrada e saída:

  • inputs - Os gatilhos de orquestração podem ser invocados com entradas, que são acessadas através do objeto de entrada de contexto. Todas as entradas devem ser serializáveis em JSON.
  • saídas - Os gatilhos de orquestração suportam valores de saída, bem como entradas. O valor de retorno da função é usado para atribuir o valor de saída e deve ser serializável por JSON.

Amostra de gatilho

O código de exemplo a seguir mostra como a função orquestradora "Hello World" mais simples pode parecer. Observe que este orquestrador de exemplo não agenda 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}!";
}

Nota

O código anterior é para Durable Functions 2.x. Para Durable Functions 1.x, você deve usar DurableOrchestrationContext em vez de IDurableOrchestrationContext. Para obter mais informações sobre as diferenças entre versões, consulte o artigo Durable Functions Versions .

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

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

Nota

A durable-functions biblioteca se encarrega de chamar o método síncrono context.done 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 do orquestrador chama funções de atividade, então aqui está um exemplo de "Hello World" 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;
}

Nota

O código anterior é para Durable Functions 2.x. Para Durable Functions 1.x, você deve usar DurableOrchestrationContext em vez de IDurableOrchestrationContext. Para obter mais informações sobre as diferenças entre versões, consulte o artigo Durable Functions versions .

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 permite criar funções que são chamadas por funções de orquestrador, conhecidas como funções de atividade.

O gatilho de atividade é configurado usando o atributo .NET ActivityTriggerAttribute .

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

O gatilho de atividade é definido pelo seguinte objeto JSON na bindings matriz de 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 do orquestrador usam para invocar essa função de atividade. Esta propriedade é opcional. Se não for especificado, 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 seu código de função Python.

Internamente, essa vinculação de gatilho sonda o armazenamento durável configurado para novos eventos de execução de atividade.

Comportamento do acionador

Aqui estão algumas notas sobre o gatilho de atividade:

  • Threading - Ao contrário do gatilho de orquestração, os gatilhos de atividade não têm restrições em relação ao threading ou E/S. Eles podem ser tratados como funções regulares.
  • Tratamento de mensagens suspeitas - Não há suporte para mensagens suspeitas em gatilhos de atividade.
  • Visibilidade da mensagem - As mensagens de gatilho de atividade são retiradas da fila e mantidas invisíveis por uma duração configurável. A visibilidade dessas mensagens é renovada automaticamente desde que o aplicativo de função esteja em execução e íntegro.
  • Valores de retorno - Os valores de retorno são serializados para JSON e persistem para o armazenamento durável configurado.

Acionar o uso

A vinculação do gatilho de atividade suporta entradas e saídas, assim como o gatilho de orquestração. Aqui estão algumas coisas a saber sobre o tratamento de entrada e saída:

  • inputs - 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 - As funções de atividade suportam valores de saída, bem como entradas. O valor de retorno da função é usado para atribuir o valor de saída e deve ser serializável por JSON.
  • metadados - As funções de atividade do .NET podem se vincular a um string instanceId parâmetro para obter a ID da instância da orquestração de chamada.

Amostra de gatilho

O código de exemplo a seguir mostra como uma função de atividade simples SayHello pode parecer.

[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 for Durable Functions v1). No entanto, os gatilhos de atividade do .NET também oferecem suporte à vinculação direta a tipos serializáveis em JSON (incluindo tipos primitivos), portanto, a mesma função pode ser simplificada da seguinte maneira:

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

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

As ligações JavaScript também podem ser passadas como parâmetros adicionais, portanto, a mesma função pode ser simplificada da seguinte forma:

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

Usando ligações de entrada e saída

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

Por exemplo, você pode levar a entrada para sua vinculação de atividade e enviar uma mensagem para um Hub de Eventos usando a associação de saída de 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 ligação do cliente de orquestração permite que você escreva funções que interagem com as funções do orquestrador. Estas funções são muitas vezes referidas como funções de cliente. Por exemplo, você pode agir em instâncias de orquestração das seguintes maneiras:

  • Inicie-os.
  • Consulte o seu estado.
  • Encerre-os.
  • Envie eventos para eles enquanto eles estão em execução.
  • Limpar histórico de instâncias.

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

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

O gatilho de cliente durável é definido pelo seguinte objeto JSON na bindings matriz de 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ção 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 do orquestrador de destino.
  • connectionName - O nome de uma configuração de aplicativo que contém uma cadeia de conexão de conta de armazenamento. A conta de armazenamento representada por essa cadeia de conexão deve ser a mesma usada pelas funções do orquestrador de destino. Se não for especificado, a cadeia de conexão de conta de armazenamento padrão para o aplicativo de função será usada.

Nota

Na maioria dos casos, recomendamos que você omita essas propriedades e confie no 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 seu código de função Python.

Utilização do cliente

Você normalmente se liga a IDurableClient (DurableOrchestrationClient in Durable Functions v1.x), que lhe dá acesso total a todas as APIs de cliente de orquestração suportadas por Durable Functions.

Normalmente, DurableClientContext você se liga à classe.

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

Aqui está um exemplo de função acionada por fila que inicia uma orquestração "HelloWorld".

[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);
}

Nota

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

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 da entidade

Os gatilhos de entidade permitem criar funções de entidade. Esse gatilho oferece suporte ao processamento de eventos para uma instância de entidade específica.

Nota

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

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

O gatilho de entidade é configurado usando o atributo .NET EntityTriggerAttribute .

O gatilho de entidade é definido pelo seguinte objeto JSON na bindings matriz de 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 de uma entidade é o nome da função.

Nota

Os gatilhos de entidade ainda não são suportados 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 seu código de função Python.

Comportamento do acionador

Aqui estão algumas notas sobre o gatilho da entidade:

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

Quaisquer alterações de estado feitas em uma entidade durante sua execução serão automaticamente persistidas após a conclusão da execução.

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

Cliente da entidade

A associação de cliente de entidade permite acionar funções de entidade de forma assíncrona. Estas funções são por vezes referidas como funções de cliente.

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

Nota

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

O cliente da entidade é definido pelo seguinte objeto JSON na bindings matriz de 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ção 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 da entidade de destino.
  • connectionName - O nome de uma configuração de aplicativo que contém uma cadeia de conexão de conta de armazenamento. A conta de armazenamento representada por essa cadeia de conexão deve ser a mesma usada pelas funções da entidade de destino. Se não for especificado, a cadeia de conexão de conta de armazenamento padrão para o aplicativo de função será usada.

Nota

Na maioria dos casos, recomendamos que você omita as propriedades opcionais e confie no 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 seu código de função Python.

Nota

Os clientes de entidade ainda não são suportados para Java.

Para obter mais informações e exemplos sobre como interagir com entidades como um cliente, consulte a documentação Entidades duráveis.

host.json configurações

Definições de configuração para funções duráveis.

Nota

Todas as versões principais do Durable Functions são suportadas em todas as versões do tempo de execução do Azure Functions. No entanto, o esquema da configuração do host.json é ligeiramente diferente, dependendo da versão do tempo de execução do Azure Functions e da versão da extensão Durable Functions que você usa. Os exemplos a seguir são para 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 deve ir na raiz da configuração do 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
  }
 }
}

Os nomes do hub de tarefas devem começar com uma letra e consistir apenas em letras e números. Se não for especificado, o nome do hub de tarefa padrão para um aplicativo de função é TestHubName. Para obter mais informações, consulte Hubs de tarefas.

Property Predefinição Description
hubName TestHubName (DurableFunctionsHub se estiver usando Durable Functions 1.x) Nomes de hub de tarefas alternativos podem ser usados para isolar vários aplicativos de Funções Duráveis uns dos outros, mesmo que estejam usando o mesmo back-end de armazenamento.
controlQueueBatchSize 32 O número de mensagens a serem extraídas da fila de controle de cada 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 da fila de controle que podem ser armazenadas em buffer na memória de cada vez, momento em que o dispatcher aguardará antes de dequeuar quaisquer mensagens adicionais.
partitionCount 4 A contagem de partições para a fila de controle. Pode ser um número inteiro positivo entre 1 e 16.
controlQueueVisibilityTimeout 5 minutos O tempo limite de visibilidade das mensagens da fila de controle desfileiradas.
workItemQueueVisibilityTimeout 5 minutos O tempo limite de visibilidade das mensagens da fila de itens de trabalho sem fila.
maxConcurrentActivityFunctions Plano de consumo: 10
Plano dedicado/Premium: 10X o número de processadores na máquina 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: 10X o número de processadores na máquina atual		 O número máximo de funções do orchestrator que podem ser processadas simultaneamente em uma única instância de host.
maxQueuePollingInterval 30 segundos O controle máximo e o intervalo de sondagem da fila de itens de trabalho 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 mais altos devido ao aumento das transações de armazenamento.
connectionName (2.7.0 e posterior)
connectionStringName (2.x)
azureStorageConnectionStringName (1.x)		 AzureWebJobsStorage O nome de uma configuração de aplicativo ou coleção de configurações que especifica como se conectar aos recursos subjacentes do Armazenamento do Azure. Quando uma única configuração de aplicativo é fornecida, ela deve ser 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 coleção de configurações que especifica como se conectar às tabelas Histórico e Instâncias. Quando uma única configuração de aplicativo é fornecida, ela deve ser uma cadeia de conexão do Armazenamento do Azure. Se não for especificado, a connectionStringName conexão (Durable 2.x) ou azureStorageConnectionStringName (Durable 1.x) será usada.
trackingStoreNamePrefix O prefixo a ser usado para as tabelas History e Instances quando trackingStoreConnectionStringName for especificado. Se não estiver definido, o valor do prefixo padrão será DurableTask. Se trackingStoreConnectionStringName não for especificado, as tabelas Histórico e Instâncias usarão o valor como seu prefixo hubName e qualquer configuração para trackingStoreNamePrefix será ignorada.
traceInputsAndOutputs false Um valor que indica se as entradas e saídas de chamadas de função devem ser rastreadas. O comportamento padrão ao rastrear 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 informações mínimas sobre a aparência das entradas e saídas sem inchar os logs ou expor inadvertidamente informações confidenciais. Definir essa propriedade como true faz com que o log de função padrão registre todo o conteúdo de entradas e saídas de função.
traceReplayEvents false Um valor que indica se os eventos de repetição de orquestração devem ser gravados no Application Insights.
eventGridTopicEndpoint A URL de um ponto de extremidade de tópico personalizado da Grade de Eventos do Azure. Quando essa propriedade é definida, os eventos de notificação do ciclo de vida da orquestração são publicados nesse ponto de extremidade. Esta propriedade suporta a resolução de Configurações do aplicativo.
eventGridKeySettingName O nome da configuração do aplicativo que contém a chave usada para autenticação com o tópico personalizado da Grade de Eventos do Azure em EventGridTopicEndpoint.
eventGridPublishRetryCount 0 O número de vezes a tentar novamente se a publicação no Tópico da Grade de Eventos falhar.
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 especificado, todos os tipos de evento serão publicados. Os valores permitidos incluem Started, Completed, , FailedTerminated.
useAppLease verdadeiro Quando definido como true, os aplicativos exigirão a aquisição de uma concessão de blob no nível do aplicativo antes de processar mensagens do hub de tarefas. Para obter mais informações, consulte a documentação de recuperação de desastres e distribuição geográfica. Disponível a partir da v2.3.0.
useLegacyPartitionManagement false Quando definido como false, usa um algoritmo de gerenciamento de partições que reduz a possibilidade de execução de função duplicada ao dimensionar. Disponível a partir da v2.3.0.
useTablePartitionManagement false Quando definido como true, usa um algoritmo de gerenciamento de partições projetado para reduzir custos para contas do Armazenamento do Azure V2. Disponível a partir da v2.10.0. Esta funcionalidade está atualmente em pré-visualização e ainda não é compatível com o plano de Consumo.
useGracefulShutdown false (Pré-visualização) Habilite o desligamento normal para reduzir a chance de desligamentos de host falharem nas execuções de funções 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 envio em lote será desativado e cada mensagem de operação será processada por uma chamada de função separada.
storeInputsInOrchestrationHistory false Quando definido como true, informa o Durable Task Framework 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 são para otimizar o desempenho. Para obter mais informações, consulte Desempenho e escala.

Próximos passos

Referência de API HTTP integrada para gerenciamento de instâncias