Guia de referência de esquema para tipos de gatilho e ação nos Aplicativos Lógicos do Azure
Esta referência descreve os tipos gerais usados para identificar gatilhos e ações na definição de fluxo de trabalho subjacente do seu aplicativo lógico, que é descrita e validada pela Linguagem de Definição de Fluxo de Trabalho. Para encontrar acionadores de conector específicos e ações que você pode usar em seus aplicativos lógicos, consulte a lista em Visão geral de conectores.
Visão geral dos gatilhos
Cada fluxo de trabalho inclui um gatilho, que define as chamadas que instanciam e iniciam o fluxo de trabalho. Aqui estão as categorias gerais de gatilho:
Um gatilho de sondagem, que verifica o ponto de extremidade de um serviço em intervalos regulares
Um gatilho push, que cria uma assinatura para um ponto de extremidade e fornece uma URL de retorno de chamada para que o ponto de extremidade possa notificar o gatilho quando o evento especificado acontecer ou os dados estiverem disponíveis. Em seguida, o gatilho aguarda a resposta do ponto de extremidade antes de disparar.
Os gatilhos têm esses elementos de nível superior, embora alguns sejam opcionais:
"<trigger-name>": {
"type": "<trigger-type>",
"inputs": { "<trigger-inputs>" },
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>
},
"conditions": [ "<array-with-conditions>" ],
"runtimeConfiguration": { "<runtime-config-options>" },
"splitOn": "<splitOn-expression>",
"operationOptions": "<operation-option>"
},
Necessário
| valor | Tipo | Description |
|---|---|---|
| <nome-gatilho> | String | O nome do gatilho |
| <tipo gatilho> | String | O tipo de gatilho como "Http" ou "ApiConnection" |
| <Entradas-gatilho> | Objeto JSON | As entradas que definem o comportamento do gatilho |
| <unidade de tempo> | String | A unidade de tempo que descreve a frequência com que o gatilho dispara: "Segundo", "Minuto", "Hora", "Dia", "Semana", "Mês" |
| <número de unidades de tempo> | Integer | Um valor que especifica a frequência com que o gatilho é acionado com base na frequência, que é o número de unidades de tempo a aguardar até que o gatilho seja acionado novamente Aqui estão os intervalos mínimo e máximo: - Mês: 1-16 meses - Dia: 1-500 dias - Hora: 1-12.000 horas - Minuto: 1-72.000 minutos - Segundo: 1-9.999.999 segundos Por exemplo, se o intervalo for 6 e a frequência for "Mês", a recorrência será a cada 6 meses. |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <array-com-condições> | Matriz | Uma matriz que contém uma ou mais condições que determinam se o fluxo de trabalho deve ser executado. Disponível apenas para gatilhos. |
| <runtime-config-options> | Objeto JSON | Você pode alterar o comportamento do tempo de execução do gatilho definindo runtimeConfiguration propriedades. Para obter mais informações, consulte Definições de configuração de tempo de execução. |
| <splitOn-expression> | String | Para gatilhos que retornam uma matriz, você pode especificar uma expressão que divide ou desagrupa itens de matriz em várias instâncias de fluxo de trabalho para processamento. |
| <opção de operação> | String | Você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Lista de tipos de gatilho
Cada tipo de gatilho tem uma interface diferente e entradas que definem o comportamento do gatilho.
Gatilhos integrados
| Tipo de acionador | Description |
|---|---|
| HTTP | Verifica ou sonda qualquer ponto de extremidade. Esse ponto de extremidade deve estar em conformidade com um contrato de gatilho específico usando um 202 padrão assíncrono ou retornando uma matriz. |
| HTTPWebhook | Cria um ponto de extremidade chamável para seu aplicativo lógico, mas chama a URL especificada para registrar ou cancelar o registro. |
| Periodicidade | Incêndios com base num calendário definido. Você pode definir uma data e hora futuras para disparar esse gatilho. Com base na frequência, você também pode especificar horários e dias para executar seu fluxo de trabalho. |
| Pedir | Cria um ponto de extremidade chamável para seu aplicativo lógico e também é conhecido como um gatilho "manual". Por exemplo, consulte Chamar fluxos de trabalho de acionamento ou aninhar com pontos de extremidade HTTP. |
Gatilhos de API gerenciados
| Tipo de acionador | Description |
|---|---|
| ApiConnection | Verifica ou sonda um ponto de extremidade usando APIs gerenciadas pela Microsoft ou "conectores". |
| ApiConnectionWebhook | Cria um ponto de extremidade chamável para o fluxo de trabalho do aplicativo lógico chamando APIs gerenciadas pela Microsoft ou "conectores" para assinar e cancelar a inscrição. |
Acionadores – Referência detalhada
Gatilho APIConnection
Esse gatilho verifica ou sonda um ponto de extremidade usando APIs gerenciadas pela Microsoft ou "conectores" para que os parâmetros desse gatilho possam diferir com base no ponto de extremidade. Muitas seções nesta definição de gatilho são opcionais. O comportamento do gatilho depende da inclusão ou não de seções.
"<APIConnection_trigger_name>": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['<connection-name>']['connectionId']"
}
},
"method": "<method-type>",
"path": "/<api-operation>",
"retryPolicy": { "<retry-behavior>" },
"queries": { "<query-parameters>" }
},
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>
},
"runtimeConfiguration": {
"concurrency": {
"runs": <max-runs>,
"maximumWaitingRuns": <max-runs-queue>
}
},
"splitOn": "<splitOn-expression>",
"operationOptions": "<operation-option>"
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <APIConnection_trigger_name> | String | O nome do gatilho |
| <nome da conexão> | String | O nome da conexão com a API gerenciada que o fluxo de trabalho usa |
| <tipo-método> | String | O método HTTP para comunicação com a API gerenciada: "Get", "put", "post", "patch", "delete" |
| <Operação API> | String | A operação de API a ser chamada |
| <unidade de tempo> | String | A unidade de tempo que descreve a frequência com que o gatilho dispara: "Segundo", "Minuto", "Hora", "Dia", "Semana", "Mês" |
| <número de unidades de tempo> | Integer | Um valor que especifica a frequência com que o gatilho é acionado com base na frequência, que é o número de unidades de tempo a aguardar até que o gatilho seja acionado novamente Aqui estão os intervalos mínimo e máximo: - Mês: 1-16 meses - Dia: 1-500 dias - Hora: 1-12.000 horas - Minuto: 1-72.000 minutos - Segundo: 1-9.999.999 segundos Por exemplo, se o intervalo for 6 e a frequência for "Mês", a recorrência será a cada 6 meses. |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
| <parâmetros-consulta> | Objeto JSON | Todos os parâmetros de consulta a serem incluídos na chamada da API. Por exemplo, o "queries": { "api-version": "2018-01-01" } objeto adiciona ?api-version=2018-01-01 à chamada. |
| <Execuções máximas> | Integer | Por padrão, as instâncias de fluxo de trabalho são executadas ao mesmo tempo (simultaneamente ou em paralelo) até o limite padrão. Para alterar esse limite definindo um novo <valor de contagem>, consulte Alterar simultaneidade de gatilho. |
| <max-runs-fila> | Integer | Quando seu fluxo de trabalho já está executando o número máximo de instâncias, que você pode alterar com base na runtimeConfiguration.concurrency.runs propriedade, todas as novas execuções são colocadas nessa fila até o limite padrão. Para alterar o limite padrão, consulte Alterar limite de execuções em espera. |
| <splitOn-expression> | String | Para gatilhos que retornam matrizes, essa expressão faz referência à matriz a ser usada para que você possa criar e executar uma instância de fluxo de trabalho para cada item de matriz, em vez de usar um loop "para cada um". Por exemplo, esta expressão representa um item na matriz retornado dentro do conteúdo do corpo do gatilho: |
| <opção de operação> | String | Você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Saídas
| Elemento | Tipo | Description |
|---|---|---|
| cabeçalhos | Objeto JSON | Os cabeçalhos da resposta |
| corpo | Objeto JSON | O corpo da resposta |
| código de estado | Integer | O código de status da resposta |
Exemplo
Esta definição de gatilho verifica se há e-mails todos os dias dentro da caixa de entrada para uma conta corporativa ou de estudante:
"When_a_new_email_arrives": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "get",
"path": "/Mail/OnNewEmail",
"queries": {
"fetchOnlyWithAttachment": false,
"folderPath": "Inbox",
"importance": "Any",
"includeAttachments": false
}
},
"recurrence": {
"frequency": "Day",
"interval": 1
}
}
ApiConnectionWebhook gatilho
Esse gatilho envia uma solicitação de assinatura para um ponto de extremidade usando uma API gerenciada pela Microsoft, fornece uma URL de retorno de chamada para onde o ponto de extremidade pode enviar uma resposta e aguarda que o ponto de extremidade responda. Para obter mais informações, consulte Assinaturas de ponto de extremidade.
"<ApiConnectionWebhook_trigger_name>": {
"type": "ApiConnectionWebhook",
"inputs": {
"body": {
"NotificationUrl": "@{listCallbackUrl()}"
},
"host": {
"connection": {
"name": "@parameters('$connections')['<connection-name>']['connectionId']"
}
},
"retryPolicy": { "<retry-behavior>" },
"queries": "<query-parameters>"
},
"runTimeConfiguration": {
"concurrency": {
"runs": <max-runs>,
"maximumWaitingRuns": <max-run-queue>
}
},
"splitOn": "<splitOn-expression>",
"operationOptions": "<operation-option>"
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <nome da conexão> | String | O nome da conexão com a API gerenciada que o fluxo de trabalho usa |
| <corpo-conteúdo> | Objeto JSON | Qualquer conteúdo de mensagem a ser enviado como carga útil para a API gerenciada |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
| <parâmetros-consulta> | Objeto JSON | Quaisquer parâmetros de consulta a serem incluídos com a chamada de API Por exemplo, o |
| <Execuções máximas> | Integer | Por padrão, as instâncias de fluxo de trabalho são executadas ao mesmo tempo (simultaneamente ou em paralelo) até o limite padrão. Para alterar esse limite definindo um novo <valor de contagem>, consulte Alterar simultaneidade de gatilho. |
| <max-runs-fila> | Integer | Quando seu fluxo de trabalho já está executando o número máximo de instâncias, que você pode alterar com base na runtimeConfiguration.concurrency.runs propriedade, todas as novas execuções são colocadas nessa fila até o limite padrão. Para alterar o limite padrão, consulte Alterar limite de execuções em espera. |
| <splitOn-expression> | String | Para gatilhos que retornam matrizes, essa expressão faz referência à matriz a ser usada para que você possa criar e executar uma instância de fluxo de trabalho para cada item de matriz, em vez de usar um loop "para cada um". Por exemplo, esta expressão representa um item na matriz retornado dentro do conteúdo do corpo do gatilho: |
| <opção de operação> | String | Você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Exemplo
Essa definição de gatilho assina a API do Outlook do Office 365, fornece uma URL de retorno de chamada para o ponto de extremidade da API e aguarda que o ponto de extremidade responda quando um novo email chega.
"When_a_new_email_arrives_(webhook)": {
"type": "ApiConnectionWebhook",
"inputs": {
"body": {
"NotificationUrl": "@{listCallbackUrl()}"
},
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"path": "/MailSubscription/$subscriptions",
"queries": {
"folderPath": "Inbox",
"hasAttachment": "Any",
"importance": "Any"
}
},
"splitOn": "@triggerBody()?['value']"
}
Acionador HTTP
Esse gatilho envia uma solicitação para o ponto de extremidade HTTP ou HTTPS especificado com base no agendamento de recorrência especificado. Em seguida, o gatilho verifica a resposta para determinar se o fluxo de trabalho é executado. Para obter mais informações, consulte Chamar pontos de extremidade de serviço sobre HTTP ou HTTPS dos Aplicativos Lógicos do Azure.
"HTTP": {
"type": "Http",
"inputs": {
"method": "<method-type>",
"uri": "<HTTP-or-HTTPS-endpoint-URL>",
"headers": { "<header-content>" },
"queries": "<query-parameters>",
"body": "<body-content>",
"authentication": { "<authentication-type-and-property-values>" },
"retryPolicy": {
"type": "<retry-behavior>"
}
},
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>
},
"runtimeConfiguration": {
"concurrency": {
"runs": <max-runs>,
"maximumWaitingRuns": <max-runs-queue>
}
},
"operationOptions": "<operation-option>"
}
Necessário
| Propriedade | valor | Tipo | Description |
|---|---|---|---|
method |
<tipo-método> | String | O método a utilizar para enviar o pedido de saída: "GET", "PUT", "POST", "PATCH" ou "DELETE" |
uri |
<HTTP-ou-HTTPS-endpoint-URL> | String | A URL do ponto de extremidade HTTP ou HTTPS para onde você deseja enviar a solicitação de saída. Tamanho máximo da cadeia: 2 KB Para um serviço ou recurso do Azure, essa sintaxe de URI inclui a ID do recurso e o caminho para o recurso que você deseja acessar. |
frequency |
<unidade de tempo> | String | A unidade de tempo que descreve a frequência com que o gatilho dispara: "Segundo", "Minuto", "Hora", "Dia", "Semana", "Mês" |
interval |
<número de unidades de tempo> | Integer | Um valor que especifica a frequência com que o gatilho é acionado com base na frequência, que é o número de unidades de tempo a aguardar até que o gatilho seja acionado novamente Aqui estão os intervalos mínimo e máximo: - Mês: 1-16 meses - Dia: 1-500 dias - Hora: 1-12.000 horas - Minuto: 1-72.000 minutos - Segundo: 1-9.999.999 segundos Por exemplo, se o intervalo for 6 e a frequência for "Mês", a recorrência será a cada 6 meses. |
Opcional
| Propriedade | valor | Tipo | Description |
|---|---|---|---|
headers |
<cabeçalho-conteúdo> | Objeto JSON | Quaisquer cabeçalhos que você precisa incluir com a solicitação Por exemplo, para definir o idioma e digitar:
|
queries |
<parâmetros-consulta> | Objeto JSON | Quaisquer parâmetros de consulta que você precise usar na solicitação Por exemplo, o |
body |
<corpo-conteúdo> | Objeto JSON | O conteúdo da mensagem a ser enviada como carga útil com a solicitação |
authentication |
<authentication-type-and-property-values> | Objeto JSON | O modelo de autenticação que a solicitação usa para autenticar solicitações de saída. Para obter mais informações, consulte Adicionar autenticação a chamadas de saída. Além do Scheduler, a authority propriedade é suportada. Quando não especificado, o valor padrão é https://management.azure.com/, mas você pode usar um valor diferente. |
retryPolicy > type |
<comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
runs |
<Execuções máximas> | Integer | Por padrão, as instâncias de fluxo de trabalho são executadas ao mesmo tempo (simultaneamente ou em paralelo) até o limite padrão. Para alterar esse limite definindo um novo <valor de contagem>, consulte Alterar simultaneidade de gatilho. |
maximumWaitingRuns |
<max-runs-fila> | Integer | Quando seu fluxo de trabalho já está executando o número máximo de instâncias, que você pode alterar com base na runtimeConfiguration.concurrency.runs propriedade, todas as novas execuções são colocadas nessa fila até o limite padrão. Para alterar o limite padrão, consulte Alterar limite de execuções em espera. |
operationOptions |
<opção de operação> | String | Você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Saídas
| Elemento | Tipo | Description |
|---|---|---|
headers |
Objeto JSON | Os cabeçalhos da resposta |
body |
Objeto JSON | O corpo da resposta |
status code |
Integer | O código de status da resposta |
Requisitos para solicitações recebidas
Para funcionar bem com seu aplicativo lógico, o ponto de extremidade deve estar em conformidade com um padrão ou contrato de gatilho específico e reconhecer estas propriedades de resposta:
| Propriedade | Obrigatório | Description |
|---|---|---|
| Código de estado | Sim | O código de status "200 OK" inicia uma execução. Qualquer outro código de status não inicia uma execução. |
| Repetir cabeçalho após | Não | O número de segundos até que seu aplicativo lógico sonde o ponto de extremidade novamente |
| Cabeçalho de localização | Não | O URL a ser chamado no próximo intervalo de sondagem. Se não for especificado, o URL original será usado. |
Exemplos de comportamentos para diferentes solicitações
| Código de estado | Tente novamente depois | Comportamento |
|---|---|---|
| 200 | {nenhum} | Execute o fluxo de trabalho e, em seguida, verifique novamente se há mais dados após a recorrência definida. |
| 200 | 10 segundos | Execute o fluxo de trabalho e, em seguida, verifique novamente se há mais dados após 10 segundos. |
| 202 | 60 segundos | Não acione o fluxo de trabalho. A próxima tentativa acontece em um minuto, sujeita à recorrência definida. Se a recorrência definida for inferior a um minuto, o cabeçalho de repetição após terá precedência. Caso contrário, a recorrência definida é usada. |
| 400 | {nenhum} | Solicitação incorreta, não execute o fluxo de trabalho. Se não retryPolicy for definido, a política padrão será usada. Depois que o número de novas tentativas for atingido, o gatilho verificará novamente os dados após a recorrência definida. |
| 500 | {nenhum} | Erro do servidor, não execute o fluxo de trabalho. Se não retryPolicy for definido, a política padrão será usada. Depois que o número de novas tentativas for atingido, o gatilho verificará novamente os dados após a recorrência definida. |
Gatilho HTTPWebhook
Esse gatilho torna seu aplicativo lógico chamável criando um ponto de extremidade que pode registrar uma assinatura chamando a URL de ponto de extremidade especificada. Quando você cria esse gatilho em seu fluxo de trabalho, uma solicitação de saída faz a chamada para registrar a assinatura. Dessa forma, o gatilho pode começar a ouvir os eventos. Quando uma operação torna esse gatilho inválido, uma solicitação de saída automaticamente faz a chamada para cancelar a assinatura. Para obter mais informações, consulte Assinaturas de ponto de extremidade.
Você também pode especificar limites assíncronos em um gatilho HTTPWebhook . O comportamento do gatilho depende das seções que você usa ou omite.
"HTTP_Webhook": {
"type": "HttpWebhook",
"inputs": {
"subscribe": {
"method": "<method-type>",
"uri": "<endpoint-subscribe-URL>",
"headers": { "<header-content>" },
"body": "<body-content>",
"authentication": { "<authentication-type>" },
"retryPolicy": { "<retry-behavior>" }
},
},
"unsubscribe": {
"method": "<method-type>",
"url": "<endpoint-unsubscribe-URL>",
"headers": { "<header-content>" },
"body": "<body-content>",
"authentication": { "<authentication-type>" }
}
},
"runTimeConfiguration": {
"concurrency": {
"runs": <max-runs>,
"maximumWaitingRuns": <max-runs-queue>
}
},
"operationOptions": "<operation-option>"
}
Alguns valores, como <method-type>, estão disponíveis para os "subscribe" objetos e "unsubscribe" .
Necessário
| valor | Tipo | Description |
|---|---|---|
| <tipo-método> | String | O método HTTP a utilizar para o pedido de subscrição: "GET", "PUT", "POST", "PATCH" ou "DELETE" |
| <endpoint-subscribe-URL> | String | O URL do ponto de extremidade para onde enviar a solicitação de assinatura |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <tipo-método> | String | O método HTTP a utilizar para o pedido de cancelamento: "GET", "PUT", "POST", "PATCH" ou "DELETE" |
| <endpoint-unsubscribe-URL> | String | O URL do ponto de extremidade para onde enviar a solicitação de cancelamento |
| <corpo-conteúdo> | String | Qualquer conteúdo de mensagem a enviar na subscrição ou pedido de cancelamento |
| <tipo de autenticação> | Objeto JSON | O modelo de autenticação que a solicitação usa para autenticar solicitações de saída. Para obter mais informações, consulte Adicionar autenticação a chamadas de saída. |
| <comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
| <Execuções máximas> | Integer | Por padrão, todas as instâncias de fluxo de trabalho são executadas ao mesmo tempo (simultaneamente ou em paralelo) até o limite padrão. Para alterar esse limite definindo um novo <valor de contagem>, consulte Alterar simultaneidade de gatilho. |
| <max-runs-fila> | Integer | Quando seu fluxo de trabalho já está executando o número máximo de instâncias, que você pode alterar com base na runtimeConfiguration.concurrency.runs propriedade, todas as novas execuções são colocadas nessa fila até o limite padrão. Para alterar o limite padrão, consulte Alterar limite de execuções em espera. |
| <opção de operação> | String | Você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Saídas
| Elemento | Tipo | Description |
|---|---|---|
| cabeçalhos | Objeto JSON | Os cabeçalhos da resposta |
| corpo | Objeto JSON | O corpo da resposta |
| código de estado | Integer | O código de status da resposta |
Exemplo
Esse gatilho cria uma assinatura para o ponto de extremidade especificado, fornece uma URL de retorno de chamada exclusiva e aguarda artigos de tecnologia recém-publicados.
"HTTP_Webhook": {
"type": "HttpWebhook",
"inputs": {
"subscribe": {
"method": "POST",
"uri": "https://pubsubhubbub.appspot.com/subscribe",
"body": {
"hub.callback": "@{listCallbackUrl()}",
"hub.mode": "subscribe",
"hub.topic": "https://pubsubhubbub.appspot.com/articleCategories/technology"
},
},
"unsubscribe": {
"method": "POST",
"url": "https://pubsubhubbub.appspot.com/subscribe",
"body": {
"hub.callback": "@{workflow().endpoint}@{listCallbackUrl()}",
"hub.mode": "unsubscribe",
"hub.topic": "https://pubsubhubbub.appspot.com/articleCategories/technology"
}
}
}
}
Acionador de periodicidade
Esse gatilho é executado com base no cronograma de recorrência especificado e fornece uma maneira fácil de criar um fluxo de trabalho em execução regular.
"Recurrence": {
"type": "Recurrence",
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>,
"startTime": "<start-date-time-with-format-YYYY-MM-DDThh:mm:ss>",
"timeZone": "<time-zone>",
"schedule": {
// Applies only when frequency is Day or Week. Separate values with commas.
"hours": [ <one-or-more-hour-marks> ],
// Applies only when frequency is Day or Week. Separate values with commas.
"minutes": [ <one-or-more-minute-marks> ],
// Applies only when frequency is Week. Separate values with commas.
"weekDays": [ "Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday" ]
}
},
"runtimeConfiguration": {
"concurrency": {
"runs": <max-runs>,
"maximumWaitingRuns": <max-runs-queue>
}
},
"operationOptions": "<operation-option>"
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <unidade de tempo> | String | A unidade de tempo que descreve a frequência com que o gatilho dispara: "Segundo", "Minuto", "Hora", "Dia", "Semana", "Mês" |
| <número de unidades de tempo> | Integer | Um valor que especifica a frequência com que o gatilho é acionado com base na frequência, que é o número de unidades de tempo a aguardar até que o gatilho seja acionado novamente Aqui estão os intervalos mínimo e máximo: - Mês: 1-16 meses - Dia: 1-500 dias - Hora: 1-12.000 horas - Minuto: 1-72.000 minutos - Segundo: 1-9.999.999 segundos Por exemplo, se o intervalo for 6 e a frequência for "Mês", a recorrência será a cada 6 meses. |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <data-início-hora-com-formato-AAAA-MM-DDThh:mm:ss> | String | A data e hora de início neste formato: AAAA-MM-DDThh:mm:ss se você especificar um fuso horário -ou- AAAA-MM-DDThh:mm:ssZ se você não especificar um fuso horário Assim, por exemplo, se você quiser 18 de setembro de 2017 às 14:00, especifique "2017-09-18T14:00:00" e especifique um fuso horário, como "Hora Padrão do Pacífico", ou especifique "2017-09-18T14:00:00Z" sem um fuso horário. Nota: Esta hora de início tem um máximo de 49 anos no futuro e deve seguir a especificação de data e hora ISO 8601 no formato de data e hora UTC, mas sem um desvio UTC. Se você não especificar um fuso horário, deverá adicionar a letra "Z" no final sem espaços. Este "Z" refere-se ao tempo náutico equivalente. Para agendas simples, a hora de início é a primeira ocorrência, enquanto para agendas complexas, o gatilho não é acionado antes da hora de início. Para obter mais informações sobre datas e horas de início, consulte Criar e agendar tarefas em execução regularmente. |
| <Fuso horário> | String | Aplica-se somente quando você especifica uma hora de início porque esse gatilho não aceita o deslocamento UTC. Especifique o fuso horário que deseja aplicar. |
| <marcas de uma ou mais horas> | Matriz inteira ou inteira | Se você especificar "Dia" ou "Semana" para frequency, poderá especificar um ou mais inteiros de 0 a 23, separados por vírgulas, como as horas do dia em que deseja executar o fluxo de trabalho. Por exemplo, se você especificar "10", "12" e "14", obterá 10h, 12h e 14h como marcas de hora. |
| <marcas de um ou mais minutos> | Matriz inteira ou inteira | Se você especificar "Dia" ou "Semana" para frequency, poderá especificar um ou mais inteiros de 0 a 59, separados por vírgulas, como os minutos da hora em que deseja executar o fluxo de trabalho. Por exemplo, você pode especificar "30" como a marca de minuto e, usando o exemplo anterior para horas do dia, você obtém 10h30, 12h30 e 14h30. |
| weekDays | String ou matriz de string | Se você especificar "Semana" para frequency, poderá especificar um ou mais dias, separados por vírgulas, quando quiser executar o fluxo de trabalho: "Segunda-feira", "Terça-feira", "Quarta-feira", "Quinta-feira", "Sexta-feira", "Sábado" e "Domingo" |
| <Execuções máximas> | Integer | Por padrão, todas as instâncias de fluxo de trabalho são executadas ao mesmo tempo (simultaneamente ou em paralelo) até o limite padrão. Para alterar esse limite definindo um novo <valor de contagem>, consulte Alterar simultaneidade de gatilho. |
| <max-runs-fila> | Integer | Quando seu fluxo de trabalho já está executando o número máximo de instâncias, que você pode alterar com base na runtimeConfiguration.concurrency.runs propriedade, todas as novas execuções são colocadas nessa fila até o limite padrão. Para alterar o limite padrão, consulte Alterar limite de execuções em espera. |
| <opção de operação> | String | Você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Exemplo 1
Este gatilho básico de recorrência é executado diariamente:
"Recurrence": {
"type": "Recurrence",
"recurrence": {
"frequency": "Day",
"interval": 1
}
}
Exemplo 2
Você pode especificar uma data e hora de início para disparar o gatilho. Esse gatilho de recorrência começa na data especificada e, em seguida, é acionado diariamente:
"Recurrence": {
"type": "Recurrence",
"recurrence": {
"frequency": "Day",
"interval": 1,
"startTime": "2017-09-18T00:00:00Z"
}
}
Exemplo 3
Este gatilho de recorrência começa em 9 de setembro de 2017 às 14:00 e dispara semanalmente todas as segundas-feiras às 10:30, 12:30 e 14:30 Hora Padrão do Pacífico:
"Recurrence": {
"type": "Recurrence",
"recurrence": {
"frequency": "Week",
"interval": 1,
"schedule": {
"hours": [ 10, 12, 14 ],
"minutes": [ 30 ],
"weekDays": [ "Monday" ]
},
"startTime": "2017-09-07T14:00:00",
"timeZone": "Pacific Standard Time"
}
}
Para obter mais informações e exemplos para esse gatilho, consulte Criar e agendar tarefas em execução regularmente.
Gatilho de solicitação
Esse gatilho torna seu aplicativo lógico chamável criando um ponto de extremidade que pode aceitar solicitações de entrada. Para esse gatilho, forneça um esquema JSON que descreva e valide a carga ou entradas que o gatilho recebe da solicitação de entrada. O esquema também facilita a referência às propriedades de gatilho de ações posteriores no fluxo de trabalho.
Para chamar esse gatilho, você deve usar a listCallbackUrl API, que é descrita na API REST do Serviço de Fluxo de Trabalho. Para saber como usar esse gatilho como um ponto de extremidade HTTP, consulte Chamar, disparar ou aninhar fluxos de trabalho com pontos de extremidade HTTP.
"manual": {
"type": "Request",
"kind": "Http",
"inputs": {
"method": "<method-type>",
"relativePath": "<relative-path-for-accepted-parameter>",
"schema": {
"type": "object",
"properties": {
"<property-name>": {
"type": "<property-type>"
}
},
"required": [ "<required-properties>" ]
}
},
"runTimeConfiguration": {
"concurrency": {
"runs": <max-runs>,
"maximumWaitingRuns": <max-run-queue>
},
},
"operationOptions": "<operation-option>"
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <nome da propriedade> | String | O nome de uma propriedade no esquema JSON, que descreve a carga útil |
| <tipo de propriedade> | String | O tipo de propriedade |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <tipo-método> | String | O método que as solicitações de entrada devem usar para chamar seu aplicativo lógico: "GET", "PUT", "POST", "PATCH", "DELETE" |
| <relative-path-for-accepted-parameter> | String | O caminho relativo para o parâmetro que a URL do ponto de extremidade pode aceitar |
| <propriedades necessárias> | Matriz | Uma ou mais propriedades que exigem valores |
| <Execuções máximas> | Integer | Por padrão, todas as instâncias de fluxo de trabalho são executadas ao mesmo tempo (simultaneamente ou em paralelo) até o limite padrão. Para alterar esse limite definindo um novo <valor de contagem>, consulte Alterar simultaneidade de gatilho. |
| <max-runs-fila> | Integer | Quando seu fluxo de trabalho já está executando o número máximo de instâncias, que você pode alterar com base na runtimeConfiguration.concurrency.runs propriedade, todas as novas execuções são colocadas nessa fila até o limite padrão. Para alterar o limite padrão, consulte Alterar limite de execuções em espera. |
| <opção de operação> | String | Você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Exemplo
Esse gatilho especifica que uma solicitação de entrada deve usar o método HTTP POST para chamar o gatilho e inclui um esquema que valida a entrada da solicitação de entrada:
"manual": {
"type": "Request",
"kind": "Http",
"inputs": {
"method": "POST",
"schema": {
"type": "object",
"properties": {
"customerName": {
"type": "String"
},
"customerAddress": {
"type": "Object",
"properties": {
"streetAddress": {
"type": "string"
},
"city": {
"type": "string"
}
}
}
}
}
}
}
Condições do acionador
Para qualquer gatilho e somente gatilhos, você pode incluir uma matriz que contenha uma ou mais expressões para condições que determinam se o fluxo de trabalho deve ser executado. Para adicionar a propriedade a um gatilho conditions em seu fluxo de trabalho, abra seu aplicativo lógico no editor de visualização de código.
Por exemplo, você pode especificar que um gatilho seja acionado somente quando um site retorna um erro interno do servidor fazendo referência ao conditions código de status do gatilho na propriedade:
"Recurrence": {
"type": "Recurrence",
"recurrence": {
"frequency": "Hour",
"interval": 1
},
"conditions": [ {
"expression": "@equals(triggers().code, 'InternalServerError')"
} ]
}
Por padrão, um gatilho é acionado somente depois de obter uma resposta "200 OK". Quando uma expressão faz referência ao código de status de um gatilho, o comportamento padrão do gatilho é substituído. Portanto, se você quiser que o gatilho dispare para mais de um código de status, como o código de status "200" e "201", você deve incluir esta expressão como sua condição:
@or(equals(triggers().code, 200),equals(triggers().code, 201))
Acionar várias execuções em uma matriz
Se o gatilho receber uma matriz para o fluxo de trabalho processar, às vezes um loop "para cada um" pode levar muito tempo para processar cada item de matriz. Em vez disso, você pode usar a propriedade SplitOn em seu gatilho para desagrupar a matriz. O desagrupamento divide os itens de matriz e inicia uma nova instância de fluxo de trabalho que é executada para cada item de matriz. Essa abordagem é útil, por exemplo, quando você deseja sondar um ponto de extremidade que pode retornar vários novos itens entre intervalos de sondagem.
Se o arquivo Swagger do gatilho descrever uma carga útil que é uma matriz, a propriedade SplitOn será adicionada automaticamente ao gatilho. Caso contrário, adicione essa propriedade dentro da carga útil de resposta que tem a matriz que você deseja desagrupar.
Antes de usar o recurso SplitOn, analise as seguintes considerações:
Se a simultaneidade de gatilho estiver ativada, o limite de SplitOn será significativamente reduzido. Se o número de itens exceder esse limite, o recurso SplitOn será desativado.
Não é possível usar o recurso SplitOn com um padrão de resposta síncrona. Qualquer fluxo de trabalho que use a propriedade SplitOn e inclua uma ação de resposta é executado de forma assíncrona e envia imediatamente uma
202 ACCEPTEDresposta.Para obter o número máximo de itens de matriz que o SplitOn pode processar em uma única execução de fluxo de trabalho, consulte Limites e configuração.
Exemplo
Suponha que você tenha um gatilho HTTP que chama uma API e recebe esta resposta:
{
"Status": "Succeeded",
"Rows": [
{
"id": 938109380,
"name": "customer-name-one"
},
{
"id": 938109381,
"name": "customer-name-two"
}
]
}
Seu fluxo de trabalho precisa apenas do conteúdo da matriz no , para Rowsque você possa criar um gatilho como este exemplo:
"HTTP_Debatch": {
"type": "Http",
"inputs": {
"uri": "https://mydomain.com/myAPI",
"method": "GET"
},
"recurrence": {
"frequency": "Second",
"interval": 1
},
"splitOn": "@triggerBody()?.Rows"
}
Nota
Se você usar o SplitOn comando, não poderá obter as propriedades que estão fora da matriz.
Portanto, para este exemplo, você não pode obter a status propriedade na resposta retornada da API.
Para evitar uma falha se a Rows propriedade não existir, este exemplo usa o ? operador.
Sua definição de fluxo de trabalho agora pode ser usada @triggerBody().name para obter os name valores, que são "customer-name-one" da primeira execução e "customer-name-two" da segunda execução. Assim, suas saídas de gatilho se parecem com estes exemplos:
{
"body": {
"id": 938109380,
"name": "customer-name-one"
}
}
{
"body": {
"id": 938109381,
"name": "customer-name-two"
}
}
Visão geral das ações
Os Aplicativos Lógicos do Azure fornecem vários tipos de ação, cada um com entradas diferentes que definem o comportamento exclusivo de uma ação. As ações têm esses elementos de alto nível, embora alguns sejam opcionais:
"<action-name>": {
"type": "<action-type>",
"inputs": {
"<input-name>": { "<input-value>" },
"retryPolicy": "<retry-behavior>"
},
"runAfter": { "<previous-trigger-or-action-status>" },
"runtimeConfiguration": { "<runtime-config-options>" },
"operationOptions": "<operation-option>"
},
Necessário
| valor | Tipo | Description |
|---|---|---|
| <nome-ação> | String | O nome da ação |
| <tipo de ação> | String | O tipo de ação, por exemplo, "Http" ou "ApiConnection" |
| <nome de entrada> | String | O nome de uma entrada que define o comportamento da ação |
| <valor de entrada> | Vários | O valor de entrada, que pode ser uma cadeia de caracteres, inteiro, objeto JSON e assim por diante |
| <anterior-trigger-or-action-status> | Objeto JSON | O nome e o status resultante para o gatilho ou ação que deve ser executado imediatamente antes que essa ação atual possa ser executada |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
| <runtime-config-options> | Objeto JSON | Para algumas ações, você pode alterar o comportamento da ação em tempo de execução definindo runtimeConfiguration propriedades. Para obter mais informações, consulte Definições de configuração de tempo de execução. |
| <opção de operação> | String | Para algumas ações, você pode alterar o comportamento padrão definindo a operationOptions propriedade. Para obter mais informações, consulte Opções de operação. |
Lista de tipos de ação
Aqui estão alguns tipos de ação comumente usados:
Tipos de ação incorporados, como estes exemplos e muito mais:
Resposta para responder a pedidos
Executar código JavaScript para executar trechos de código JavaScript
Função para chamar o Azure Functions
Ações de operação de dados, como Join, Compose, Table, Select e outras que criam ou transformam dados de várias entradas
Fluxo de trabalho para chamar outro fluxo de trabalho de aplicativo lógico
Tipos de ação de API gerenciada, como ApiConnection e ApiConnectionWebHook, que chamam vários conectores e APIs gerenciados pela Microsoft, por exemplo, Azure Service Bus, Office 365 Outlook, Power BI, Azure Blob Storage, OneDrive, GitHub e muito mais
Controle tipos de ação de fluxo de trabalho, como If, Foreach, Switch, Scope e Until, que contêm outras ações e ajudam a organizar a execução do fluxo de trabalho
Ações incorporadas
| Tipo de ação | Description |
|---|---|
| Compose | Cria uma única saída a partir de entradas, que podem ter vários tipos. |
| Executar código JavaScript | Execute trechos de código JavaScript que se encaixam em critérios específicos. Para obter requisitos de código e mais informações, consulte Adicionar e executar trechos de código com código embutido. |
| Função | Chama uma função do Azure. |
| HTTP | Chama um ponto de extremidade HTTP. |
| Join | Cria uma cadeia de caracteres de todos os itens em uma matriz e separa esses itens com um caractere delimitador especificado. |
| Analisar JSON | Cria tokens amigáveis a partir de propriedades no conteúdo JSON. Em seguida, você pode fazer referência a essas propriedades incluindo os tokens em seu aplicativo lógico. |
| Consulta | Cria uma matriz a partir de itens em outra matriz com base em uma condição ou filtro. |
| Response | Cria uma resposta a uma chamada ou solicitação de entrada. |
| Selecionar | Cria uma matriz com objetos JSON transformando itens de outra matriz com base no mapa especificado. |
| Tabela | Cria uma tabela CSV ou HTML a partir de uma matriz. |
| Terminate | Interrompe um fluxo de trabalho em execução ativa. |
| Wait | Pausa o fluxo de trabalho por uma duração especificada ou até a data e hora especificadas. |
| Workflow | Aninha um fluxo de trabalho dentro de outro fluxo de trabalho. |
Ações gerenciadas da API
| Tipo de ação | Description |
|---|---|
| ApiConnection | Chama um ponto de extremidade HTTP usando uma API gerenciada pela Microsoft. |
| ApiConnectionWebhook | Funciona como HTTP Webhook, mas usa uma API gerenciada pela Microsoft. |
Controlar ações do fluxo de trabalho
Essas ações ajudam a controlar a execução do fluxo de trabalho e incluem outras ações. De fora de uma ação de fluxo de trabalho de controle, você pode referenciar diretamente ações dentro dessa ação de fluxo de trabalho de controle. Por exemplo, se você tiver uma Http ação dentro de um escopo, poderá fazer referência à @body('Http') expressão de qualquer lugar no fluxo de trabalho. No entanto, as ações que existem dentro de uma ação de fluxo de trabalho de controle só podem "executar depois" de outras ações que estão na mesma estrutura de fluxo de trabalho de controle.
| Tipo de ação | Description |
|---|---|
| ForEach | Execute as mesmas ações em um loop para cada item em uma matriz. |
| Se | Execute ações com base em se a condição especificada é true ou false. |
| Scope | Execute ações com base no status do grupo a partir de um conjunto de ações. |
| Switch | Execute ações organizadas em casos em que os valores de expressões, objetos ou tokens correspondam aos valores especificados por cada caso. |
| Até | Execute ações em um loop até que a condição especificada seja verdadeira. |
Ações - Referência pormenorizada
Ação APIConnection
Essa ação envia uma solicitação HTTP para uma API gerenciada pela Microsoft e requer informações sobre a API e os parâmetros, além de uma referência a uma conexão válida.
"<action-name>": {
"type": "ApiConnection",
"inputs": {
"host": {
"connection": {
"name": "@parameters('$connections')['<api-name>']['connectionId']"
},
"<other-action-specific-input-properties>"
},
"method": "<method-type>",
"path": "/<api-operation>",
"retryPolicy": "<retry-behavior>",
"queries": { "<query-parameters>" },
"<other-action-specific-properties>"
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <nome-ação> | String | O nome da ação fornecida pelo conector |
| <Nome da API> | String | O nome da API gerenciada pela Microsoft que é usada para a conexão |
| <tipo-método> | String | O método HTTP para chamar a API: "GET", "PUT", "POST", "PATCH" ou "DELETE" |
| <Operação API> | String | A operação de API a ser chamada |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <propriedades de entrada específicas de outras ações> | Objeto JSON | Quaisquer outras propriedades de entrada que se apliquem a esta ação específica |
| <comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
| <parâmetros-consulta> | Objeto JSON | Todos os parâmetros de consulta a serem incluídos na chamada da API. Por exemplo, o |
| <propriedades específicas de outras ações> | Objeto JSON | Quaisquer outras propriedades que se apliquem a esta ação específica |
Exemplo
Esta definição descreve a ação Enviar um email para o conector do Office 365 Outlook, que é uma API gerenciada pela Microsoft:
"Send_an_email": {
"type": "ApiConnection",
"inputs": {
"body": {
"Body": "Thank you for your membership!",
"Subject": "Hello and welcome!",
"To": "Sophie.Owen@contoso.com"
},
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "POST",
"path": "/Mail"
},
"runAfter": {}
}
Ação APIConnectionWebhook
Essa ação envia uma solicitação de assinatura por HTTP para um ponto de extremidade usando uma API gerenciada pela Microsoft, fornece uma URL de retorno de chamada para onde o ponto de extremidade pode enviar uma resposta e aguarda que o ponto de extremidade responda. Para obter mais informações, consulte Assinaturas de ponto de extremidade.
"<action-name>": {
"type": "ApiConnectionWebhook",
"inputs": {
"subscribe": {
"method": "<method-type>",
"uri": "<api-subscribe-URL>",
"headers": { "<header-content>" },
"body": "<body-content>",
"authentication": { "<authentication-type>" },
"retryPolicy": "<retry-behavior>",
"queries": { "<query-parameters>" },
"<other-action-specific-input-properties>"
},
"unsubscribe": {
"method": "<method-type>",
"uri": "<api-unsubscribe-URL>",
"headers": { "<header-content>" },
"body": "<body-content>",
"authentication": { "<authentication-type>" },
"<other-action-specific-properties>"
},
},
"runAfter": {}
}
Alguns valores, como <method-type>, estão disponíveis para os "subscribe" objetos e "unsubscribe" .
Necessário
| valor | Tipo | Description |
|---|---|---|
| <nome-ação> | String | O nome da ação fornecida pelo conector |
| <tipo-método> | String | O método HTTP a ser usado para assinar ou cancelar a assinatura de um ponto de extremidade: "GET", "PUT", "POST", "PATCH" ou "DELETE" |
| <api-assinar-URL> | String | O URI a ser usado para assinar a API |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <api-unsubscribe-URL> | String | O URI a ser usado para cancelar a assinatura da API |
| <cabeçalho-conteúdo> | Objeto JSON | Quaisquer cabeçalhos a enviar no pedido Por exemplo, para definir o idioma e digitar em uma solicitação:
|
| <corpo-conteúdo> | Objeto JSON | Qualquer conteúdo de mensagem a enviar no pedido |
| <tipo de autenticação> | Objeto JSON | O modelo de autenticação que a solicitação usa para autenticar solicitações de saída. Para obter mais informações, consulte Adicionar autenticação a chamadas de saída. |
| <comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
| <parâmetros-consulta> | Objeto JSON | Quaisquer parâmetros de consulta a serem incluídos com a chamada de API Por exemplo, o |
| <propriedades de entrada específicas de outras ações> | Objeto JSON | Quaisquer outras propriedades de entrada que se apliquem a esta ação específica |
| <propriedades específicas de outras ações> | Objeto JSON | Quaisquer outras propriedades que se apliquem a esta ação específica |
Você também pode especificar limites em uma ação ApiConnectionWebhook da mesma forma que os limites assíncronos HTTP.
Ação de composição
Esta ação cria uma única saída a partir de várias entradas, incluindo expressões. Tanto a saída quanto as entradas podem ter qualquer tipo que os Aplicativos Lógicos do Azure suportem nativamente, como matrizes, objetos JSON, XML e binário. Em seguida, você pode usar a saída da ação em outras ações.
"Compose": {
"type": "Compose",
"inputs": "<inputs-to-compose>",
"runAfter": {}
},
Necessário
| valor | Tipo | Description |
|---|---|---|
| <inputs-to-compose> | Qualquer | As entradas para criar uma única saída |
Exemplo 1
Esta definição de ação mescla-se abcdefg com um espaço à direita e o valor 1234:
"Compose": {
"type": "Compose",
"inputs": "abcdefg 1234",
"runAfter": {}
},
Aqui está a saída que esta ação cria:
abcdefg 1234
Exemplo 2
Esta definição de ação mescla uma variável de cadeia de caracteres que contém abcdefg e uma variável inteira que contém 1234:
"Compose": {
"type": "Compose",
"inputs": "@{variables('myString')}@{variables('myInteger')}",
"runAfter": {}
},
Aqui está a saída que esta ação cria:
"abcdefg1234"
Executar ação de código JavaScript
Essa ação executa um trecho de código JavaScript e retorna os resultados por meio de um token que as ações subsequentes no fluxo de trabalho podem referenciar.
"Execute_JavaScript_Code": {
"type": "JavaScriptCode",
"inputs": {
"code": "<JavaScript-code-snippet>",
"explicitDependencies": {
"actions": [ <preceding-actions> ],
"includeTrigger": true
}
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <Trecho de código JavaScript> | Varia | O código JavaScript que você deseja executar. Para obter requisitos de código e mais informações, consulte Executar trechos de código em fluxos de trabalho.
|
Necessário em alguns casos
O explicitDependencies atributo especifica que você deseja incluir explicitamente os resultados do gatilho, ações anteriores ou ambas como dependências para seu trecho de código. Para obter mais informações sobre como adicionar essas dependências, consulte Adicionar dependências como parâmetros a uma ação de código embutido.
Para o includeTrigger atributo, você pode especificar true ou false valores.
| valor | Tipo | Description |
|---|---|---|
| <Ações anteriores> | Matriz de cadeias de carateres | Uma matriz com os nomes das ações no formato JSON como dependências. Certifique-se de usar os nomes de ação que aparecem na definição do fluxo de trabalho, onde os nomes de ação usam sublinhados (_), não espaços (" "). |
Exemplo 1
Esta ação executa um código que obtém o nome do fluxo de trabalho do aplicativo lógico e retorna o texto "Hello world from <logic-app-name>" como resultado. Neste exemplo, o código faz referência ao nome do fluxo de trabalho acessando a workflowContext.workflow.name propriedade por meio do objeto somente workflowContext leitura. Para obter mais informações sobre como usar o workflowContext objeto, consulte Acionador de referência e resultados de ação em seu código.
"Execute_JavaScript_Code": {
"type": "JavaScriptCode",
"inputs": {
"code": "var text = \"Hello world from \" + workflowContext.workflow.name;\r\n\r\nreturn text;"
},
"runAfter": {}
}
Exemplo 2
Essa ação executa código em um fluxo de trabalho de aplicativo lógico que é acionado quando um novo email chega em uma conta do Outlook. O fluxo de trabalho também usa a ação de email Enviar aprovação do Office 365 Outlook que encaminha o conteúdo do email recebido junto com uma solicitação de aprovação.
O código extrai os endereços de e-mail da Body propriedade da mensagem de email e retorna os endereços juntamente com o SelectedOption valor da propriedade da ação de aprovação. A ação inclui explicitamente a ação Enviar email de aprovação como uma dependência no actions objeto dentro do explicitDependencies objeto.
"Execute_JavaScript_Code": {
"type": "JavaScriptCode",
"inputs": {
"code": "var myResult = /(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))/g;\r\n\r\nvar email = workflowContext.trigger.outputs.body.Body;\r\n\r\nvar reply = workflowContext.actions.Send_approval_email.outputs.body.SelectedOption;\r\n\r\nreturn email.match(myResult) + \" - \" + reply;\r\n;",
"explicitDependencies": {
"actions": [
"Send_approval_email"
]
}
},
"runAfter": {}
}
Ação da função
Esta ação chama uma função do Azure criada anteriormente.
"<Azure-function-name>": {
"type": "Function",
"inputs": {
"function": {
"id": "<Azure-function-ID>"
},
"method": "<method-type>",
"headers": { "<header-content>" },
"body": { "<body-content>" },
"queries": { "<query-parameters>" }
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <Azure-function-ID> | String | A ID do recurso para a função do Azure que você deseja chamar. Aqui está o formato para este valor: "/subscriptions/Azure-subscription-ID>/<resourceGroups/Azure-resource-group>/providers/Microsoft.Web/sites/Azure-function-app-name/functions/<<<Azure-function-name">> |
| <tipo-método> | String | O método HTTP a ser usado para chamar a função: "GET", "PUT", "POST", "PATCH" ou "DELETE" Se não for especificado, o padrão é o método "POST". |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <cabeçalho-conteúdo> | Objeto JSON | Quaisquer cabeçalhos a enviar com a chamada Por exemplo, para definir o idioma e digitar em uma solicitação:
|
| <corpo-conteúdo> | Objeto JSON | Qualquer conteúdo de mensagem a enviar no pedido |
| <parâmetros-consulta> | Objeto JSON | Quaisquer parâmetros de consulta a serem incluídos com a chamada de API Por exemplo, o |
| <propriedades de entrada específicas de outras ações> | Objeto JSON | Quaisquer outras propriedades de entrada que se apliquem a esta ação específica |
| <propriedades específicas de outras ações> | Objeto JSON | Quaisquer outras propriedades que se apliquem a esta ação específica |
Quando você salva seu aplicativo lógico, o mecanismo de aplicativos lógicos executa estas verificações na função referenciada:
Seu fluxo de trabalho deve ter acesso à função.
Seu fluxo de trabalho pode usar apenas um gatilho HTTP padrão ou um gatilho de webhook JSON genérico.
O mecanismo de Aplicativos Lógicos obtém e armazena em cache a URL do gatilho, que é usada em tempo de execução. No entanto, se qualquer operação invalidar a URL armazenada em cache, a ação Função falhará no tempo de execução. Para corrigir esse problema, salve o aplicativo lógico novamente para que o aplicativo lógico obtenha e armazene em cache a URL do gatilho novamente.
A função não pode ter nenhuma rota definida.
Apenas os níveis de autorização "função" e "anónimo" são permitidos.
Exemplo
Esta definição de ação chama a função "GetProductID" criada anteriormente:
"GetProductID": {
"type": "Function",
"inputs": {
"function": {
"id": "/subscriptions/<XXXXXXXXXXXXXXXXXXXX>/resourceGroups/myLogicAppResourceGroup/providers/Microsoft.Web/sites/InventoryChecker/functions/GetProductID"
},
"method": "POST",
"headers": {
"x-ms-date": "@utcnow()"
},
"body": {
"Product_ID": "@variables('ProductID')"
}
},
"runAfter": {}
}
Ação HTTP
Essa ação envia uma solicitação para o ponto de extremidade HTTP ou HTTPS especificado e verifica a resposta para determinar se o fluxo de trabalho é executado. Para obter mais informações, consulte Chamar pontos de extremidade de serviço sobre HTTP ou HTTPS dos Aplicativos Lógicos do Azure.
"HTTP": {
"type": "Http",
"inputs": {
"method": "<method-type>",
"uri": "<HTTP-or-HTTPS-endpoint-URL>",
"headers": { "<header-content>" },
"queries": { "<query-parameters>" },
"body": "<body-content>",
"authentication": { "<authentication-type-and-property-values>" },
"retryPolicy": {
"type": "<retry-behavior>"
},
},
"runAfter": {}
}
Necessário
| Propriedade | valor | Tipo | Description |
|---|---|---|---|
method |
<tipo-método> | String | O método a utilizar para enviar o pedido de saída: "GET", "PUT", "POST", "PATCH" ou "DELETE" |
uri |
<HTTP-ou-HTTPS-endpoint-URL> | String | A URL do ponto de extremidade HTTP ou HTTPS para onde você deseja enviar a solicitação de saída. Tamanho máximo da cadeia: 2 KB Para um serviço ou recurso do Azure, essa sintaxe de URI inclui a ID do recurso e o caminho para o recurso que você deseja acessar. |
Opcional
| Propriedade | valor | Tipo | Description |
|---|---|---|---|
headers |
<cabeçalho-conteúdo> | Objeto JSON | Quaisquer cabeçalhos que você precisa incluir com a solicitação Por exemplo, para definir o idioma e digitar:
|
queries |
<parâmetros-consulta> | Objeto JSON | Quaisquer parâmetros de consulta que você precise usar na solicitação Por exemplo, o |
body |
<corpo-conteúdo> | Objeto JSON | O conteúdo da mensagem a ser enviada como carga útil com a solicitação |
authentication |
<authentication-type-and-property-values> | Objeto JSON | O modelo de autenticação que a solicitação usa para autenticar solicitações de saída. Para obter mais informações, consulte Adicionar autenticação a chamadas de saída. Além do Scheduler, a authority propriedade é suportada. Quando não especificado, o valor padrão é https://management.azure.com/, mas você pode usar um valor diferente. |
retryPolicy > type |
<comportamento de repetição> | Objeto JSON | Personaliza o comportamento de repetição para falhas intermitentes, que têm o código de status 408, 429 e 5XX e quaisquer exceções de conectividade. Para obter mais informações, consulte Repetir políticas. |
| <propriedades de entrada específicas de outras ações> | <entrada-propriedade> | Objeto JSON | Quaisquer outras propriedades de entrada que se apliquem a esta ação específica |
| <propriedades específicas de outras ações> | <valor da propriedade> | Objeto JSON | Quaisquer outras propriedades que se apliquem a esta ação específica |
Exemplo
Esta definição de ação obtém as últimas notícias enviando uma solicitação para o ponto de extremidade especificado:
"HTTP": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "https://mynews.example.com/latest"
}
}
Ação Participar
Essa ação cria uma cadeia de caracteres de todos os itens em uma matriz e separa esses itens com o caractere delimitador especificado.
"Join": {
"type": "Join",
"inputs": {
"from": <array>,
"joinWith": "<delimiter>"
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <matriz> | Matriz | A matriz ou expressão que fornece os itens de origem. Se você especificar uma expressão, coloque-a entre aspas duplas. |
| <delimitador> | Cadeia de caracteres únicos | O caractere que separa cada item na cadeia de caracteres |
Exemplo
Suponha que você tenha uma variável "myIntegerArray" criada anteriormente que contenha essa matriz inteira:
[1,2,3,4]
Esta definição de ação obtém os valores da variável usando a variables() função em uma expressão e cria essa cadeia de caracteres com esses valores, que são separados por uma vírgula: "1,2,3,4"
"Join": {
"type": "Join",
"inputs": {
"from": "@variables('myIntegerArray')",
"joinWith": ","
},
"runAfter": {}
}
Analisar ação JSON
Esta ação cria campos ou tokens amigáveis a partir das propriedades no conteúdo JSON. Em seguida, você pode acessar essas propriedades em seu aplicativo lógico usando os tokens. Por exemplo, quando quiser usar a saída JSON de serviços como o Barramento de Serviço do Azure e o Azure Cosmos DB, você pode incluir essa ação em seu aplicativo lógico para que possa referenciar mais facilmente os dados nessa saída.
"Parse_JSON": {
"type": "ParseJson",
"inputs": {
"content": "<JSON-source>",
"schema": { "<JSON-schema>" }
},
"runAfter": {}
},
Necessário
| valor | Tipo | Description |
|---|---|---|
| <JSON-fonte> | Objeto JSON | O conteúdo JSON que você deseja analisar |
| <Esquema JSON> | Objeto JSON | O esquema JSON que descreve o conteúdo JSON subjacente, que a ação usa para analisar o conteúdo JSON de origem. Dica: No Logic Apps Designer, você pode fornecer o esquema ou fornecer uma carga útil de exemplo para que a ação possa gerar o esquema. |
Exemplo
Esta definição de ação cria esses tokens que você pode usar em seu fluxo de trabalho, mas somente em ações executadas após a ação Analisar JSON :
FirstName, , LastNamee Email
"Parse_JSON": {
"type": "ParseJson",
"inputs": {
"content": {
"Member": {
"Email": "Sophie.Owen@contoso.com",
"FirstName": "Sophie",
"LastName": "Owen"
}
},
"schema": {
"type": "object",
"properties": {
"Member": {
"type": "object",
"properties": {
"Email": {
"type": "string"
},
"FirstName": {
"type": "string"
},
"LastName": {
"type": "string"
}
}
}
}
}
},
"runAfter": { }
},
Neste exemplo, a propriedade "content" especifica o conteúdo JSON para a ação a ser analisada. Você também pode fornecer esse conteúdo JSON como a carga útil de exemplo para gerar o esquema.
"content": {
"Member": {
"FirstName": "Sophie",
"LastName": "Owen",
"Email": "Sophie.Owen@contoso.com"
}
},
A propriedade "schema" especifica o esquema JSON usado para descrever o conteúdo JSON:
"schema": {
"type": "object",
"properties": {
"Member": {
"type": "object",
"properties": {
"FirstName": {
"type": "string"
},
"LastName": {
"type": "string"
},
"Email": {
"type": "string"
}
}
}
}
}
Ação de consulta
Esta ação cria uma matriz a partir de itens em outra matriz com base em uma condição ou filtro especificado.
"Filter_array": {
"type": "Query",
"inputs": {
"from": <array>,
"where": "<condition-or-filter>"
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <matriz> | Matriz | A matriz ou expressão que fornece os itens de origem. Se você especificar uma expressão, coloque-a entre aspas duplas. |
| <condição-ou-filtro> | String | A condição usada para filtrar itens na matriz de origem Nota: Se nenhum valor satisfizer a condição, a ação criará uma matriz vazia. |
Exemplo
Esta definição de ação cria uma matriz que tem valores maiores do que o valor especificado, que é dois:
"Filter_array": {
"type": "Query",
"inputs": {
"from": [ 1, 3, 0, 5, 4, 2 ],
"where": "@greater(item(), 2)"
}
}
Response action
Essa ação cria a carga útil para a resposta a uma solicitação HTTP.
"Response" {
"type": "Response",
"kind": "http",
"inputs": {
"statusCode": 200,
"headers": { <response-headers> },
"body": { <response-body> }
},
"runAfter": {}
},
Necessário
| valor | Tipo | Description |
|---|---|---|
| <código de status-resposta> | Integer | O código de status HTTP que é enviado para a solicitação de entrada. O código padrão é "200 OK", mas o código pode ser qualquer código de status válido que comece com 2xx, 4xx ou 5xx, mas não com 3xxx. |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <cabeçalhos-resposta> | Objeto JSON | Um ou mais cabeçalhos para incluir na resposta |
| <corpo-resposta> | Vários | O corpo da resposta, que pode ser uma cadeia de caracteres, objeto JSON ou até mesmo conteúdo binário de uma ação anterior |
Exemplo
Esta definição de ação cria uma resposta a uma solicitação HTTP com o código de status especificado, o corpo da mensagem e os cabeçalhos da mensagem:
"Response": {
"type": "Response",
"inputs": {
"statusCode": 200,
"body": {
"ProductID": 0,
"Description": "Organic Apples"
},
"headers": {
"x-ms-date": "@utcnow()",
"content-type": "application/json"
}
},
"runAfter": {}
}
Restrições
Ao contrário de outras ações, a ação Resposta tem restrições especiais:
Seu fluxo de trabalho pode usar a ação Resposta somente quando o fluxo de trabalho começa com um gatilho de solicitação HTTP, o que significa que seu fluxo de trabalho deve ser acionado por uma solicitação HTTP.
Seu fluxo de trabalho pode usar a ação Resposta em qualquer lugar, exceto dentro de loops Foreach, loops Till, incluindo loops sequenciais e ramificações paralelas.
A solicitação original obtém a resposta do fluxo de trabalho somente quando todas as ações exigidas pela ação Resposta são concluídas dentro do limite de tempo limite HTTP.
No entanto, se o fluxo de trabalho chamar outro aplicativo lógico como um fluxo de trabalho aninhado, o fluxo de trabalho pai aguardará até que o fluxo de trabalho aninhado termine, não importa quanto tempo passe antes que o fluxo de trabalho aninhado termine.
Quando seu fluxo de trabalho usa a ação Resposta e um padrão de resposta síncrona, o fluxo de trabalho também não pode usar o comando splitOn na definição de gatilho porque esse comando cria várias execuções. Verifique esse caso quando o método PUT for usado e, se verdadeiro, retorne uma resposta de "solicitação incorreta".
Caso contrário, se o fluxo de trabalho usar o comando splitOn e uma ação Resposta, o fluxo de trabalho será executado de forma assíncrona e retornará imediatamente uma resposta "202 ACEITO".
Quando a execução do fluxo de trabalho atinge a ação Resposta, mas a solicitação de entrada já recebeu uma resposta, a ação Resposta é marcada como "Falha" devido ao conflito. E, como resultado, a execução do aplicativo lógico também é marcada com o status "Falha".
Selecionar ação
Esta ação cria uma matriz com objetos JSON transformando itens de outra matriz com base no mapa especificado. A matriz de saída e a matriz de origem sempre têm o mesmo número de itens. Embora não seja possível alterar o número de objetos na matriz de saída, você pode adicionar ou remover propriedades e seus valores nesses objetos. A select propriedade especifica pelo menos um par chave-valor que define o mapa para transformar itens na matriz de origem. Um par chave-valor representa uma propriedade e seu valor em todos os objetos na matriz de saída.
"Select": {
"type": "Select",
"inputs": {
"from": <array>,
"select": {
"<key-name>": "<expression>",
"<key-name>": "<expression>"
}
},
"runAfter": {}
},
Necessário
| valor | Tipo | Description |
|---|---|---|
| <matriz> | Matriz | A matriz ou expressão que fornece os itens de origem. Certifique-se de colocar uma expressão entre aspas duplas. Nota: Se a matriz de origem estiver vazia, a ação criará uma matriz vazia. |
| <nome-chave> | String | O nome da propriedade atribuído ao resultado da <expressão> Para adicionar uma nova propriedade em todos os objetos na matriz de saída, forneça um <nome-chave> para essa propriedade e uma <expressão> para o valor da propriedade. Para remover uma propriedade de todos os objetos na matriz, omita o <nome-chave> dessa propriedade. |
| <expressão> | String | A expressão que transforma o item na matriz de origem e atribui o resultado ao <nome-chave> |
A ação Selecionar cria uma matriz como saída, portanto, qualquer ação que queira usar essa saída deve aceitar uma matriz ou você deve convertê-la no tipo que a ação do consumidor aceita. Por exemplo, para converter a matriz de saída em uma cadeia de caracteres, você pode passar essa matriz para a ação Redigir e, em seguida, fazer referência à saída da ação Compor em suas outras ações.
Exemplo
Esta definição de ação cria uma matriz de objeto JSON a partir de uma matriz inteira. A ação itera através da matriz de origem, obtém cada valor inteiro usando a @item() expressão e atribui cada valor à propriedade ""number em cada objeto JSON:
"Select": {
"type": "Select",
"inputs": {
"from": [ 1, 2, 3 ],
"select": {
"number": "@item()"
}
},
"runAfter": {}
},
Aqui está a matriz que esta ação cria:
[ { "number": 1 }, { "number": 2 }, { "number": 3 } ]
Para usar essa saída de matriz em outras ações, passe essa saída para uma ação Compor :
"Compose": {
"type": "Compose",
"inputs": "@body('Select')",
"runAfter": {
"Select": [ "Succeeded" ]
}
},
Em seguida, você pode usar a saída da ação Redigir em suas outras ações, por exemplo, a ação Office 365 Outlook - Enviar um email :
"Send_an_email": {
"type": "ApiConnection",
"inputs": {
"body": {
"Body": "@{outputs('Compose')}",
"Subject": "Output array from Select and Compose actions",
"To": "<your-email@domain>"
},
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/Mail"
},
"runAfter": {
"Compose": [ "Succeeded" ]
}
},
Ação da tabela
Esta ação cria uma tabela CSV ou HTML a partir de uma matriz. Para matrizes com objetos JSON, essa ação cria automaticamente os cabeçalhos de coluna a partir dos nomes de propriedade dos objetos. Para matrizes com outros tipos de dados, você deve especificar os cabeçalhos e valores de coluna. Por exemplo, essa matriz inclui as propriedades "ID" e "Product_Name" que essa ação pode usar para os nomes de cabeçalho de coluna:
[ {"ID": 0, "Product_Name": "Apples"}, {"ID": 1, "Product_Name": "Oranges"} ]
"Create_<CSV | HTML>_table": {
"type": "Table",
"inputs": {
"format": "<CSV | HTML>",
"from": <array>,
"columns": [
{
"header": "<column-name>",
"value": "<column-value>"
},
{
"header": "<column-name>",
"value": "<column-value>"
}
]
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <CSV ou HTML> | String | O formato da tabela que pretende criar |
| <matriz> | Matriz | A matriz ou expressão que fornece os itens de origem para a tabela Nota: Se a matriz de origem estiver vazia, a ação criará uma tabela vazia. |
Opcional
Para especificar ou personalizar cabeçalhos e valores de coluna, use a columns matriz. Quando header-value os pares têm o mesmo nome de cabeçalho, seus valores aparecem na mesma coluna sob esse nome de cabeçalho. Caso contrário, cada cabeçalho exclusivo define uma coluna exclusiva.
| valor | Tipo | Description |
|---|---|---|
| <nome da coluna> | String | O nome do cabeçalho de uma coluna |
| <valor-coluna> | Qualquer | O valor nessa coluna |
Exemplo 1
Suponha que você tenha uma variável "myItemArray" criada anteriormente que atualmente contém essa matriz:
[ {"ID": 0, "Product_Name": "Apples"}, {"ID": 1, "Product_Name": "Oranges"} ]
Esta definição de ação cria uma tabela CSV a partir da variável "myItemArray". A expressão usada pela from propriedade obtém a matriz de "myItemArray" usando a variables() função:
"Create_CSV_table": {
"type": "Table",
"inputs": {
"format": "CSV",
"from": "@variables('myItemArray')"
},
"runAfter": {}
}
Aqui está a tabela CSV que esta ação cria:
ID,Product_Name
0,Apples
1,Oranges
Exemplo 2
Esta definição de ação cria uma tabela HTML a partir da variável "myItemArray". A expressão usada pela from propriedade obtém a matriz de "myItemArray" usando a variables() função:
"Create_HTML_table": {
"type": "Table",
"inputs": {
"format": "HTML",
"from": "@variables('myItemArray')"
},
"runAfter": {}
}
Aqui está a tabela HTML que esta ação cria:
| ID | Product_Name |
|---|---|
| 0 | Maçãs |
| 1 | Laranjas |
Exemplo 3
Esta definição de ação cria uma tabela HTML a partir da variável "myItemArray". No entanto, este exemplo substitui os nomes de cabeçalho de coluna padrão por "Stock_ID" e "Description" e adiciona a palavra "Organic" aos valores na coluna "Description".
"Create_HTML_table": {
"type": "Table",
"inputs": {
"format": "HTML",
"from": "@variables('myItemArray')",
"columns": [
{
"header": "Stock_ID",
"value": "@item().ID"
},
{
"header": "Description",
"value": "@concat('Organic ', item().Product_Name)"
}
]
},
"runAfter": {}
},
Aqui está a tabela HTML que esta ação cria:
| Stock_ID | Description |
|---|---|
| 0 | Maçãs Biológicas |
| 1 | Laranjas Orgânicas |
Encerrar ação
Essa ação interrompe a execução de uma instância de fluxo de trabalho, cancela todas as ações em andamento, ignora todas as ações restantes e retorna o status especificado. Por exemplo, você pode usar a ação Encerrar quando seu aplicativo lógico precisa sair completamente de um estado de erro. Essa ação não afeta as ações já concluídas e não pode aparecer dentro dos loops Foreach e Until , incluindo loops sequenciais.
"Terminate": {
"type": "Terminate",
"inputs": {
"runStatus": "<status>",
"runError": {
"code": "<error-code-or-name>",
"message": "<error-message>"
}
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <estado> | String | O status a ser retornado para a execução: "Falha", "Cancelado" ou "Bem-sucedido" |
Opcional
As propriedades do objeto "runStatus" aplicam-se somente quando a propriedade "runStatus" está definida como status "Failed".
| valor | Tipo | Description |
|---|---|---|
| <erro-código-ou-nome> | String | O código ou nome do erro |
| <mensagem de erro> | String | A mensagem ou o texto que descreve o erro e todas as ações que o usuário do aplicativo pode executar |
Exemplo
Esta definição de ação interrompe a execução de um fluxo de trabalho, define o status da execução como "Falha" e retorna o status, um código de erro e uma mensagem de erro:
"Terminate": {
"type": "Terminate",
"inputs": {
"runStatus": "Failed",
"runError": {
"code": "Unexpected response",
"message": "The service received an unexpected response. Please try again."
}
},
"runAfter": {}
}
Aguarde a ação
Esta ação pausa a execução do fluxo de trabalho para o intervalo especificado ou até o tempo especificado, mas não ambos.
Intervalo especificado
"Delay": {
"type": "Wait",
"inputs": {
"interval": {
"count": <number-of-units>,
"unit": "<interval>"
}
},
"runAfter": {}
},
Hora especificada
"Delay_until": {
"type": "Wait",
"inputs": {
"until": {
"timestamp": "<date-time-stamp>"
}
},
"runAfter": {}
},
Necessário
Exemplo 1
Esta definição de ação pausa o fluxo de trabalho por 15 minutos:
"Delay": {
"type": "Wait",
"inputs": {
"interval": {
"count": 15,
"unit": "Minute"
}
},
"runAfter": {}
},
Exemplo 2
Esta definição de ação pausa o fluxo de trabalho até a hora especificada:
"Delay_until": {
"type": "Wait",
"inputs": {
"until": {
"timestamp": "2017-10-01T00:00:00Z"
}
},
"runAfter": {}
},
Acão de Fluxo de Trabalho
Essa ação chama outro aplicativo lógico criado anteriormente, o que significa que você pode incluir e reutilizar outros fluxos de trabalho de aplicativos lógicos. Você também pode usar as saídas do aplicativo lógico filho ou aninhado em ações que seguem o aplicativo lógico aninhado, desde que o aplicativo lógico filho retorne uma resposta.
O mecanismo de Aplicativos Lógicos verifica o acesso ao gatilho que você deseja chamar, portanto, certifique-se de que você pode acessar esse gatilho. Além disso, o aplicativo lógico aninhado deve atender a estes critérios:
Um gatilho torna o aplicativo lógico aninhado chamável, como um gatilho Request ou HTTP
A mesma assinatura do Azure que seu aplicativo lógico pai
Para usar as saídas do aplicativo lógico aninhado em seu aplicativo lógico pai, o aplicativo lógico aninhado deve ter uma ação Resposta
"<nested-logic-app-name>": {
"type": "Workflow",
"inputs": {
"body": { "<body-content" },
"headers": { "<header-content>" },
"host": {
"triggerName": "<trigger-name>",
"workflow": {
"id": "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group>/providers/Microsoft.Logic/<nested-logic-app-name>"
}
}
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <nested-logic-app-name> | String | O nome do aplicativo lógico que você deseja chamar |
| <nome-gatilho> | String | O nome do gatilho no aplicativo lógico aninhado que você deseja chamar |
| <Azure-subscription-ID> | String | A ID de assinatura do Azure para o aplicativo lógico aninhado |
| <Azure-resource-group> | String | O nome do grupo de recursos do Azure para o aplicativo lógico aninhado |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <cabeçalho-conteúdo> | Objeto JSON | Quaisquer cabeçalhos a enviar com a chamada |
| <corpo-conteúdo> | Objeto JSON | Qualquer conteúdo de mensagem a enviar com a chamada |
Saídas
As saídas desta ação variam com base na ação Resposta do aplicativo de lógica aninhada. Se o aplicativo lógico aninhado não incluir uma ação Resposta, as saídas estarão vazias.
Exemplo
Depois que a ação "Start_search" for concluída com êxito, essa definição de ação de fluxo de trabalho chamará outro aplicativo lógico chamado "Get_product_information", que passa as entradas especificadas:
"actions": {
"Start_search": { <action-definition> },
"Get_product_information": {
"type": "Workflow",
"inputs": {
"body": {
"ProductID": "24601",
},
"host": {
"id": "/subscriptions/XXXXXXXXXXXXXXXXXXXXXXXXXX/resourceGroups/InventoryManager-RG/providers/Microsoft.Logic/Get_product_information",
"triggerName": "Find_product"
},
"headers": {
"content-type": "application/json"
}
},
"runAfter": {
"Start_search": [ "Succeeded" ]
}
}
},
Controlar detalhes da ação do fluxo de trabalho
Para cada ação
Essa ação de looping itera através de uma matriz e executa ações em cada item de matriz. Por padrão, o loop "para cada um" é executado em paralelo até um número máximo de loops. Para esse máximo, consulte Limites e configuração. Saiba como criar loops "para cada um".
"For_each": {
"type": "Foreach",
"actions": {
"<action-1>": { "<action-definition-1>" },
"<action-2>": { "<action-definition-2>" }
},
"foreach": "<for-each-expression>",
"runAfter": {},
"runtimeConfiguration": {
"concurrency": {
"repetitions": <count>
}
},
"operationOptions": "<operation-option>"
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <ação-1... n> | String | Os nomes das ações executadas em cada item de matriz |
| <ação-definição-1... n> | Objeto JSON | As definições das ações executadas |
| <para cada expressão> | String | A expressão que faz referência a cada item na matriz especificada |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <count> | Integer | Por padrão, as iterações de loop "para cada" são executadas ao mesmo tempo (simultaneamente ou em paralelo) até o limite padrão. Para alterar esse limite definindo um novo <valor de contagem>, consulte Alterar a simultaneidade de loop "para cada". |
| <opção de operação> | String | Para executar um loop "para cada um" sequencialmente, em vez de em paralelo, defina a opção de operação como Sequential ou< a <contagem>> para 1, mas não ambas. Para obter mais informações, consulte Executar loops "para cada um" sequencialmente. |
Exemplo
Esse loop "para cada um" envia um e-mail para cada item na matriz, que contém anexos de um e-mail recebido. O loop envia um e-mail, incluindo o anexo, para uma pessoa que revisa o anexo.
"For_each": {
"type": "Foreach",
"actions": {
"Send_an_email": {
"type": "ApiConnection",
"inputs": {
"body": {
"Body": "@base64ToString(items('For_each')?['Content'])",
"Subject": "Review attachment",
"To": "Sophie.Owen@contoso.com"
},
"host": {
"connection": {
"id": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/Mail"
},
"runAfter": {}
}
},
"foreach": "@triggerBody()?['Attachments']",
"runAfter": {}
}
Para especificar apenas uma matriz que é passada como saída do gatilho, essa expressão obtém a <matriz de nome> de matriz do corpo do gatilho. Para evitar uma falha se a matriz não existir, a expressão usa o ? operador:
@triggerBody()?['<array-name>']
Se ação
Essa ação, que é uma instrução condicional, avalia uma expressão que representa uma condição e executa uma ramificação diferente com base em se a condição é verdadeira ou falsa. Se a condição for verdadeira, a condição será marcada com o status "Aprovado". Saiba como criar instruções condicionais.
"Condition": {
"type": "If",
"expression": { "<condition>" },
"actions": {
"<action-1>": { "<action-definition>" }
},
"else": {
"actions": {
"<action-2>": { "<action-definition" }
}
},
"runAfter": {}
}
| valor | Tipo | Description |
|---|---|---|
| <condição> | Objeto JSON | A condição, que pode ser uma expressão, para avaliar |
| <ação-1> | Objeto JSON | A ação a ser executada quando <a condição> for avaliada como true |
| <Ação-Definição> | Objeto JSON | Definição da ação |
| <ação-2> | Objeto JSON | A ação a ser executada quando <a condição> for avaliada como falsa |
As ações nos actions objetos ou else obtêm estes status:
- "Sucesso" quando eles correm e têm sucesso
- "Falhou" quando eles são executados e falham
- "Ignorado" quando a respetiva ramificação não é executada
Exemplo
Essa condição especifica que, quando a variável inteira tem um valor maior que zero, o fluxo de trabalho verifica um site. Se a variável for zero ou menos, o fluxo de trabalho verificará um site diferente.
"Condition": {
"type": "If",
"expression": {
"and": [ {
"greater": [ "@variables('myIntegerVariable')", 0 ]
} ]
},
"actions": {
"HTTP - Check this website": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "http://this-url"
},
"runAfter": {}
}
},
"else": {
"actions": {
"HTTP - Check this other website": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "http://this-other-url"
},
"runAfter": {}
}
}
},
"runAfter": {}
}
Como as condições usam expressões
Aqui estão alguns exemplos que mostram como você pode usar expressões em condições:
| JSON | Result |
|---|---|
| "expressão": "@parameters('hasSpecialAction>'<)" | Apenas para expressões booleanas, a condição passa para qualquer valor avaliado como true. Para converter outros tipos para booleano, use estas funções: |
| "expressão": "@greater(actions('action>').output.value, parameters('threshold>'<<))" | Para funções de comparação, a ação é executada somente quando a saída da <ação> é maior do que o <valor limite.> |
| "expressão": "@or(greater(actions('action').output.value, parameters('threshold')), less(actions('same-action>>'<<<).output.value, 100))"> | Para funções lógicas e criação de expressões booleanas aninhadas, a ação é executada quando a saída da <ação> é maior que o valor limite> ou inferior a <100. |
| "expressão": "@equals(length(actions('action>'<).outputs.errors), 0))" | Você pode usar funções de matriz para verificar se a matriz tem algum item. A ação é executada quando a errors matriz está vazia. |
Ação de âmbito
Essa ação agrupa logicamente as ações em escopos, que obtêm seu próprio status depois que as ações nesse escopo terminam de ser executadas. Em seguida, você pode usar o status do escopo para determinar se outras ações são executadas. Saiba como criar escopos.
"Scope": {
"type": "Scope",
"actions": {
"<inner-action-1>": {
"type": "<action-type>",
"inputs": { "<action-inputs>" },
"runAfter": {}
},
"<inner-action-2>": {
"type": "<action-type>",
"inputs": { "<action-inputs>" },
"runAfter": {}
}
}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <inner-action-1... n> | Objeto JSON | Uma ou mais ações executadas dentro do escopo |
| <entradas de ação> | Objeto JSON | Os inputs para cada ação |
Ação Switch
Essa ação, também conhecida como instrução switch, organiza outras ações em casos e atribui um valor a cada caso, exceto para o caso padrão, se existir. Quando o fluxo de trabalho é executado, a ação Alternar compara o valor de uma expressão, objeto ou token com os valores especificados para cada caso. Se a ação Alternar encontrar um caso correspondente, seu fluxo de trabalho executará apenas as ações para esse caso. Cada vez que a ação Alternar é executada, existe apenas um caso correspondente ou não existem correspondências. Se não existirem correspondências, a ação Alternar executa as ações padrão. Saiba como criar instruções switch.
"Switch": {
"type": "Switch",
"expression": "<expression-object-or-token>",
"cases": {
"Case": {
"actions": {
"<action-name>": { "<action-definition>" }
},
"case": "<matching-value>"
},
"Case_2": {
"actions": {
"<action-name>": { "<action-definition>" }
},
"case": "<matching-value>"
}
},
"default": {
"actions": {
"<default-action-name>": { "<default-action-definition>" }
}
},
"runAfter": {}
}
Necessário
| valor | Tipo | Description |
|---|---|---|
| <expressão-objeto-ou-token> | Varia | A expressão, o objeto JSON ou o token a ser avaliado |
| <nome-ação> | String | O nome da ação a ser executada para o caso correspondente |
| <Ação-Definição> | Objeto JSON | A definição da ação a ser executada para o caso correspondente |
| <valor de correspondência> | Varia | O valor a comparar com o resultado avaliado |
Opcional
| valor | Tipo | Description |
|---|---|---|
| <default-action-name> | String | O nome da ação padrão a ser executada quando não houver nenhum caso correspondente |
| <default-action-definition> | Objeto JSON | A definição para a ação a ser executada quando não houver nenhum caso correspondente |
Exemplo
Esta definição de ação avalia se a pessoa que responde ao e-mail de solicitação de aprovação selecionou a opção "Aprovar" ou a opção "Rejeitar". Com base nessa escolha, a ação Alternar executa as ações para o caso correspondente, que é enviar outro e-mail para o respondente, mas com uma redação diferente em cada caso.
"Switch": {
"type": "Switch",
"expression": "@body('Send_approval_email')?['SelectedOption']",
"cases": {
"Case": {
"actions": {
"Send_an_email": {
"type": "ApiConnection",
"inputs": {
"Body": "Thank you for your approval.",
"Subject": "Response received",
"To": "Sophie.Owen@contoso.com"
},
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/Mail"
},
"runAfter": {}
},
"case": "Approve"
},
"Case_2": {
"actions": {
"Send_an_email_2": {
"type": "ApiConnection",
"inputs": {
"Body": "Thank you for your response.",
"Subject": "Response received",
"To": "Sophie.Owen@contoso.com"
},
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/Mail"
},
"runAfter": {}
},
"case": "Reject"
}
},
"default": {
"actions": {
"Send_an_email_3": {
"type": "ApiConnection",
"inputs": {
"Body": "Please respond with either 'Approve' or 'Reject'.",
"Subject": "Please respond",
"To": "Sophie.Owen@contoso.com"
},
"host": {
"connection": {
"name": "@parameters('$connections')['office365']['connectionId']"
}
},
"method": "post",
"path": "/Mail"
},
"runAfter": {}
}
},
"runAfter": {
"Send_approval_email": [
"Succeeded"
]
}
}
Até à ação
Esta ação de loop contém ações que são executadas até que a condição especificada seja verdadeira. O loop verifica a condição como a última etapa após todas as outras ações terem sido executadas. Você pode incluir mais de uma ação no "actions" objeto, e a ação deve definir pelo menos um limite. Saiba como criar loops "até".
"Until": {
"type": "Until",
"actions": {
"<action-name>": {
"type": "<action-type>",
"inputs": { "<action-inputs>" },
"runAfter": {}
},
"<action-name>": {
"type": "<action-type>",
"inputs": { "<action-inputs>" },
"runAfter": {}
}
},
"expression": "<condition>",
"limit": {
"count": <loop-count>,
"timeout": "<loop-timeout>"
},
"runAfter": {}
}
| valor | Tipo | Description |
|---|---|---|
| <nome-ação> | String | O nome da ação que você deseja executar dentro do loop |
| <tipo de ação> | String | O tipo de ação que você deseja executar |
| <entradas de ação> | Vários | As entradas para que a ação seja executada |
| <condição> | String | A condição ou expressão a ser avaliada depois que todas as ações no loop terminarem de ser executadas |
| <contagem de loops> | Integer | O limite no maior número de loops que a ação pode executar. Para obter mais informações sobre o limite padrão e o limite máximo, consulte Limites e configuração para Aplicativos Lógicos do Azure. |
| <tempo limite de loop> | String | O limite no maior tempo que o loop pode ser executado. O valor padrão timeout é , que é PT1Ho formato ISO 8601 necessário. |
Nota
Se a expressão depender da saída de qualquer ação dentro do loop Till, certifique-se de levar em conta qualquer falha resultante dessa ação.
Exemplo
Essa definição de ação de loop envia uma solicitação HTTP para a URL especificada até que uma destas condições seja atendida:
- A solicitação recebe uma resposta com o código de status "200 OK".
- O loop foi executado 60 vezes.
- O loop durou uma hora.
"Run_until_loop_succeeds_or_expires": {
"type": "Until",
"actions": {
"HTTP": {
"type": "Http",
"inputs": {
"method": "GET",
"uri": "http://myurl"
},
"runAfter": {}
}
},
"expression": "@equals(outputs('HTTP')['statusCode'], 200)",
"limit": {
"count": 60,
"timeout": "PT1H"
},
"runAfter": {}
}
Webhooks e subscrições
Os gatilhos e ações baseados em Webhook não verificam regularmente os pontos de extremidade, mas aguardam eventos ou dados específicos nesses pontos de extremidade. Esses gatilhos e ações assinam os pontos de extremidade fornecendo uma URL de retorno de chamada para que o ponto de extremidade possa enviar respostas.
A subscribe chamada acontece quando o fluxo de trabalho muda de alguma forma, por exemplo, quando as credenciais são renovadas ou quando os parâmetros de entrada mudam para um gatilho ou ação. Esta chamada usa os mesmos parâmetros que as ações HTTP padrão.
A unsubscribe chamada acontece automaticamente quando uma operação torna o gatilho ou ação inválido, por exemplo:
- Excluir ou desativar o gatilho.
- Excluir ou desabilitar o fluxo de trabalho.
- Eliminar ou desativar a subscrição.
Para dar suporte a essas chamadas, a @listCallbackUrl() expressão retorna uma "URL de retorno de chamada" exclusiva para o gatilho ou ação. Essa URL representa um identificador exclusivo para os pontos de extremidade que usam a API REST do serviço. Os parâmetros para esta função são os mesmos que o gatilho ou ação webhook.
Alterar a duração assíncrona
Para gatilhos e ações, você pode limitar a duração do padrão assíncrono a um intervalo de tempo específico adicionando a limit.timeout propriedade. Dessa forma, se a ação não tiver terminado quando o intervalo expirar, o status da ação será marcado como Cancelled com o ActionTimedOut código. A timeout propriedade usa o formato ISO 8601.
"<trigger-or-action-name>": {
"type": "Workflow | Webhook | Http | ApiConnectionWebhook | ApiConnection",
"inputs": {},
"limit": {
"timeout": "PT10S"
},
"runAfter": {}
}
Definições de configuração de tempo de execução
Você pode alterar o comportamento de tempo de execução padrão para gatilhos e ações adicionando essas runtimeConfiguration propriedades à definição de gatilho ou ação.
| Propriedade | Type | Description | Gatilho ou ação |
|---|---|---|---|
runtimeConfiguration.concurrency.runs |
Integer | Altere o limite padrão no número de instâncias de fluxo de trabalho que podem ser executadas ao mesmo tempo (simultaneamente ou em paralelo). Ajustar esse valor pode ajudar a limitar o número de solicitações que os sistemas de back-end recebem. Definir a propriedade para funciona da mesma forma que definir a Para alterar o limite padrão, consulte Alterar simultaneidade de gatilho ou Instâncias de gatilho sequencialmente. |
Todos os gatilhos |
runtimeConfiguration.concurrency.maximumWaitingRuns |
Integer | Altere o limite padrão no número de instâncias de fluxo de trabalho que devem aguardar para serem executadas quando seu aplicativo lógico já estiver executando o máximo de instâncias simultâneas. Para alterar o limite padrão, consulte Alterar limite de execuções em espera. |
Todos os gatilhos |
runtimeConfiguration.concurrency.repetitions |
Integer | Altere o limite padrão no número de iterações de loop "para cada" que podem ser executadas ao mesmo tempo (simultaneamente ou em paralelo). Definir a propriedade para funciona da mesma forma que definir a Para alterar o limite padrão, consulte Alterar simultaneidade "para cada" ou Executar loops "para cada" sequencialmente. |
Ação: |
runtimeConfiguration.paginationPolicy.minimumItemCount |
Integer | Para ações específicas que suportam e têm a paginação ativada, esse valor especifica o número mínimo de resultados a serem recuperados. Para ativar a paginação, consulte Obter dados, itens ou resultados em massa usando a paginação |
Ação: Variada |
runtimeConfiguration.secureData.properties |
Matriz | Em muitos gatilhos e ações, essas configurações ocultam entradas, saídas ou ambas do histórico de execução do aplicativo lógico. Para saber mais sobre como proteger esses dados, consulte Ocultar entradas e saídas do histórico de execução. |
A maioria dos gatilhos e ações |
runtimeConfiguration.staticResult |
Objeto JSON | Para ações que suportam e têm a configuração de resultado estático ativada, o objeto tem estes staticResult atributos: - - Para ativar resultados estáticos, consulte Testar aplicativos lógicos com dados fictícios configurando resultados estáticos |
Ação: Variada |
Opções de operação
Você pode alterar o comportamento padrão para gatilhos e ações com a propriedade na definição de gatilho operationOptions ou ação.
| Opção de operação | Tipo | Description | Gatilho ou ação |
|---|---|---|---|
DisableAsyncPattern |
String | Execute ações baseadas em HTTP de forma síncrona, em vez de assíncrona. Para definir essa opção, consulte Executar ações de forma síncrona. |
Ações: |
IncludeAuthorizationHeadersInOutputs |
String | Para aplicativos lógicos que habilitam o OAuth com ID do Microsoft Entra para autorizar o acesso de chamadas de entrada a um ponto de extremidade de gatilho baseado em solicitação, inclua o Authorization cabeçalho do token de acesso OAuth nas saídas do gatilho. Para obter mais informações, consulte Incluir cabeçalho 'Autorização' nas saídas de gatilho de solicitação. |
Gatilhos: |
Sequential |
String | Execute iterações de loop "para cada" uma de cada vez, em vez de todas ao mesmo tempo em paralelo. Esta opção funciona da mesma forma que definir a Para definir essa opção, consulte Executar loops "para cada um" sequencialmente. |
Ação: |
SingleInstance |
String | Execute o gatilho para cada instância do aplicativo lógico sequencialmente e aguarde a conclusão da execução ativa anteriormente antes de acionar a próxima instância do aplicativo lógico. Esta opção funciona da mesma forma que definir a Para definir essa opção, consulte Instâncias de gatilho sequencialmente. |
Todos os gatilhos |
SuppressWorkflowHeaders |
String | Não envie x-ms-* cabeçalhos de metadados em solicitações de saída. Por padrão, o serviço Aplicativos Lógicos do Azure inclui cabeçalhos de metadados extras com o prefixo x-ms- no nome do cabeçalho como parte das solicitações de saída. No entanto, alguns serviços herdados não aceitam solicitações com cabeçalhos desconhecidos extras, resultando em solicitações com falha. |
Ações: |
SuppressWorkflowHeadersOnResponse |
String | Não envie x-ms-* cabeçalhos de metadados em respostas a solicitações de gatilho de entrada. Por padrão, o serviço Aplicativos Lógicos do Azure envia respostas a solicitações de entrada que incluem cabeçalhos de metadados extras com o prefixo x-ms- no nome do cabeçalho. No entanto, alguns serviços herdados não aceitam solicitações ou respostas com cabeçalhos desconhecidos extras, resultando em solicitações com falha. |
Gatilhos: |
Alterar simultaneidade dos acionadores
Por padrão, todas as instâncias de fluxo de trabalho do aplicativo lógico são executadas ao mesmo tempo (simultaneamente ou em paralelo). Esse comportamento significa que cada instância de gatilho é acionada antes que a instância de fluxo de trabalho anteriormente ativa termine a execução. No entanto, o número de instâncias em execução simultânea tem um limite padrão. Quando o número de instâncias de fluxo de trabalho em execução simultânea atingir esse limite, quaisquer outras novas instâncias deverão aguardar para serem executadas. Esse limite ajuda a controlar o número de solicitações que os sistemas de back-end recebem.
Quando você ativa o controle de simultaneidade do gatilho, as instâncias de gatilho são executadas em paralelo até o limite padrão. Para alterar esse limite de simultaneidade padrão, você pode usar o editor de visualização de código ou o Designer de Aplicativos Lógicos porque alterar a configuração de simultaneidade por meio do designer adiciona ou atualiza a runtimeConfiguration.concurrency.runs propriedade na definição de gatilho subjacente e vice-versa. Essa propriedade controla o número máximo de novas instâncias de fluxo de trabalho que podem ser executadas em paralelo.
Antes de habilitar a simultaneidade em um gatilho, analise as seguintes considerações:
Não é possível desativar a simultaneidade depois de ativar o controle de simultaneidade.
Se o número máximo de execuções de gatilho simultâneas atingir o grau máximo de paralelismo, as execuções de gatilho subsequentes poderão sofrer limitação ou erros "429 - Muitas solicitações". Se você configurar uma política de repetição que lida com erros 429, o gatilho poderá enfrentar um ciclo de repetição e comportamento de limitação que causa longos atrasos no processamento de novas solicitações de gatilho.
Quando a simultaneidade está habilitada, o limite de SplitOn é significativamente reduzido para matrizes de desloteamento. Se o número de itens exceder esse limite, o recurso SplitOn será desativado.
Quando a simultaneidade está habilitada, uma instância de aplicativo lógico de longa execução pode fazer com que novas instâncias de aplicativo lógico entrem em um estado de espera. Esse estado impede que os Aplicativos Lógicos do Azure criem novas instâncias e acontece mesmo quando o número de execuções simultâneas é menor do que o número máximo especificado de execuções simultâneas.
Para interromper esse estado, cancele as instâncias mais antigas que ainda estão em execução.
No menu do aplicativo lógico, selecione Visão geral.
Na seção Histórico de execuções, selecione a instância mais antiga que ainda está em execução, por exemplo:
Gorjeta
Para exibir apenas as instâncias que ainda estão em execução, abra a lista Todos e selecione Em execução.
Em Execução do aplicativo lógico, selecione Cancelar execução.
Para contornar essa possibilidade, adicione um tempo limite a qualquer ação que possa atrasar essas execuções. Se você estiver trabalhando no editor de códigos, consulte Alterar a duração assíncrona. Caso contrário, se você estiver usando o designer, siga estas etapas:
No fluxo de trabalho do aplicativo lógico, selecione a ação à qual deseja adicionar um tempo limite. No canto superior direito da ação, selecione o botão de reticências (...) e, em seguida, selecione Configurações.
Em Tempo limite, especifique a duração do tempo limite no formato ISO 8601.
Para executar seu aplicativo lógico sequencialmente, defina a simultaneidade do gatilho como
1usando o editor de visualização de código ou o designer. Certifique-se de que você também não defina a propriedade dooperationOptionsgatilho comoSingleInstanceno editor de visualização de código. Caso contrário, você receberá um erro de validação. Para obter mais informações, consulte Instâncias de gatilho sequencialmente.
Editar na visualização de código
Na definição de gatilho subjacente, adicione a runtimeConfiguration.concurrency.runs propriedade e defina o valor com base nos limites de simultaneidade do gatilho. Para executar o fluxo de trabalho sequencialmente, defina o valor da propriedade como 1.
Este exemplo limita execuções simultâneas a 10 instâncias:
"<trigger-name>": {
"type": "<trigger-name>",
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>,
},
"runtimeConfiguration": {
"concurrency": {
"runs": 10
}
}
}
Para obter mais informações, consulte Definições de configuração de tempo de execução.
Editar no Logic Apps Designer
No canto superior direito do gatilho, selecione o botão de reticências (...) e, em seguida, selecione Configurações.
Em Controle de simultaneidade, defina Limite como Ativado.
Arraste o controle deslizante Grau de paralelismo para o valor desejado. Para executar seu aplicativo lógico sequencialmente, arraste o valor do controle deslizante para 1.
Alterar "para cada" simultaneidade
Por padrão, todas as iterações de loop "para cada" são executadas ao mesmo tempo (simultaneamente ou em paralelo). Esse comportamento significa que cada iteração começa a ser executada antes que a iteração anterior termine de ser executada. No entanto, o número de iterações em execução simultânea tem um limite padrão. Quando o número de iterações em execução simultânea atinge esse limite, quaisquer outras iterações devem aguardar para serem executadas.
Para alterar o limite padrão, você pode usar o editor de visualização de código ou o Designer de Aplicativos Lógicos porque alterar a configuração de simultaneidade por meio do designer adiciona ou atualiza a runtimeConfiguration.concurrency.repetitions propriedade na definição de ação subjacente "para cada um" e vice-versa. Esta propriedade controla o número máximo de iterações que podem ser executadas em paralelo.
Nota
Se você definir a ação "para cada um" para ser executada sequencialmente usando o designer ou o editor de visualização de código, não defina a propriedade da ação como Sequential no editor de visualização de operationOptions código. Caso contrário, você receberá um erro de validação. Para obter mais informações, consulte Executar loops "para cada um" sequencialmente.
Editar na visualização de código
Na definição subjacente "para cada um", adicione ou atualize a runtimeConfiguration.concurrency.repetitions propriedade, que pode ter um valor que varia de 1 e 50.
Aqui está um exemplo que limita execuções simultâneas a 10 iterações:
"For_each" {
"type": "Foreach",
"actions": { "<actions-to-run>" },
"foreach": "<for-each-expression>",
"runAfter": {},
"runtimeConfiguration": {
"concurrency": {
"repetitions": 10
}
}
}
Para obter mais informações, consulte Definições de configuração de tempo de execução.
Editar no Logic Apps Designer
No Para cada ação, no canto superior direito, selecione o botão de reticências (...) e, em seguida, selecione Configurações.
Em Controle de simultaneidade, defina Controle de simultaneidade como Ativado.
Arraste o controle deslizante Grau de paralelismo para o valor desejado. Para executar seu aplicativo lógico sequencialmente, arraste o valor do controle deslizante para 1.
Alterar o limite de execuções em espera
Por padrão, todas as instâncias de fluxo de trabalho do aplicativo lógico são executadas ao mesmo tempo (simultaneamente ou em paralelo). Esse comportamento significa que cada instância de gatilho é acionada antes que a instância de fluxo de trabalho anteriormente ativa termine a execução. No entanto, existe um limite padrão para o número de instâncias de fluxo de trabalho em execução simultânea. Quando o número de execuções simultâneas atingir esse limite, quaisquer outras novas instâncias de fluxo de trabalho deverão aguardar para serem executadas. Também existe um limite padrão no número de instâncias de fluxo de trabalho em espera. Quando o número de instâncias em espera atinge esse limite, o mecanismo de Aplicativos Lógicos do Azure não aceita mais novas instâncias de fluxo de trabalho para execução. Os gatilhos de solicitação e webhook retornam 429 - Muitos erros de solicitações e gatilhos recorrentes começam a ignorar tentativas de sondagem.
Você pode alterar o limite padrão na simultaneidade do gatilho, bem como o limite padrão em execuções em espera. No entanto, essa mudança retarda principalmente o gatilho para aliviar a pressão devido à simultaneidade. Por exemplo, se você tiver um gatilho de sondagem e a fila de execução em espera estiver cheia devido a execuções em andamento, os Aplicativos Lógicos do Azure interromperão a sondagem. Se seu fluxo de trabalho usa um gatilho baseado em solicitação e a fila de execução em espera está cheia, os Aplicativos Lógicos do Azure começam a retornar o erro 429. Existem alguns cenários em que os Aplicativos Lógicos do Azure não podem impedir que o gatilho faça sondagem sem introduzir falhas e optam por adicionar essas execuções à fila de execuções em espera de qualquer maneira, sem falhar nas execuções de chamada.
Na definição de gatilho subjacente, adicione a runtimeConfiguration.concurrency.maximumWaitingRuns propriedade, que pode ter um valor que varia de 1 a 100.
"<trigger-name>": {
"type": "<trigger-name>",
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>,
},
"runtimeConfiguration": {
"concurrency": {
"maximumWaitingRuns": 50
}
}
}
Para obter mais informações, consulte Definições de configuração de tempo de execução.
Acionar instâncias sequencialmente
Para executar cada instância de fluxo de trabalho do aplicativo lógico somente depois que a instância anterior terminar a execução, defina o gatilho para ser executado sequencialmente. Você pode usar o editor de exibição de código ou o Designer de Aplicativos Lógicos porque alterar a configuração de simultaneidade por meio do designer também adiciona ou atualiza a runtimeConfiguration.concurrency.runs propriedade na definição de gatilho subjacente e vice-versa.
Nota
Quando você definir um gatilho para ser executado sequencialmente usando o designer ou o editor de visualização de código, não defina a propriedade do gatilho como Sequential no editor de visualização de operationOptions código.
Caso contrário, você receberá um erro de validação.
Editar na visualização de código
Na definição de gatilho, defina uma dessas propriedades, mas não ambas.
Defina a runtimeConfiguration.concurrency.runs propriedade como 1:
"<trigger-name>": {
"type": "<trigger-name>",
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>,
},
"runtimeConfiguration": {
"concurrency": {
"runs": 1
}
}
}
-ou-
Defina a operationOptions propriedade como SingleInstance:
"<trigger-name>": {
"type": "<trigger-name>",
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>,
},
"operationOptions": "SingleInstance"
}
Para obter mais informações, consulte Definições de configuração de tempo de execução e Opções de operação.
Editar no Logic Apps Designer
No canto superior direito do gatilho, selecione o botão de reticências (...) e, em seguida, selecione Configurações.
Em Controle de simultaneidade, defina Limite como Ativado.
Arraste o controle deslizante Grau de paralelismo para o número
1.
Executar loops "para cada um" sequencialmente
Para executar uma iteração de loop "para cada" somente depois que a iteração anterior terminar de ser executada, defina a ação "para cada" para ser executada sequencialmente. Você pode usar o editor de visualização de código ou o Designer de Aplicativos Lógicos porque alterar a simultaneidade da ação por meio do designer também adiciona ou atualiza a runtimeConfiguration.concurrency.repetitions propriedade na definição de ação subjacente e vice-versa.
Nota
Quando você definir uma ação "para cada" para ser executada sequencialmente usando o designer ou o editor de visualização de código, não defina a propriedade da ação como Sequential no editor de visualização de operationOptions código.
Caso contrário, você receberá um erro de validação.
Editar na visualização de código
Na definição de ação, defina uma dessas propriedades, mas não ambas.
Defina a runtimeConfiguration.concurrency.repetitions propriedade como 1:
"For_each" {
"type": "Foreach",
"actions": { "<actions-to-run>" },
"foreach": "<for-each-expression>",
"runAfter": {},
"runtimeConfiguration": {
"concurrency": {
"repetitions": 1
}
}
}
-ou-
Defina a operationOptions propriedade como Sequential:
"For_each" {
"type": "Foreach",
"actions": { "<actions-to-run>" },
"foreach": "<for-each-expression>",
"runAfter": {},
"operationOptions": "Sequential"
}
Para obter mais informações, consulte Definições de configuração de tempo de execução e Opções de operação.
Editar no Logic Apps Designer
No canto superior direito de cada ação, selecione o botão de reticências (...) e, em seguida, selecione Configurações.
Em Controle de simultaneidade, defina Controle de simultaneidade como Ativado.
Arraste o controle deslizante Grau de paralelismo para o número
1.
Executar ações em um padrão de operação síncrono
Por padrão, a ação HTTP e as ações APIConnection nos Aplicativos Lógicos do Azure seguem o padrão de operação assíncrona padrão, enquanto a ação Resposta segue o padrão de operação síncrona. O padrão assíncrono especifica que, depois que uma ação chama ou envia uma solicitação para o ponto de extremidade, serviço, sistema ou API especificado, o recetor retorna imediatamente uma resposta "202 ACEITO". Este código confirma que o destinatário aceitou o pedido, mas não terminou o processamento. A resposta pode incluir um cabeçalho que especifica a URL e um location ID de atualização que o chamador pode usar para pesquisar continuamente ou verificar o status da solicitação assíncrona até que o recetor pare de processar e retorne uma resposta de sucesso "200 OK" ou outra resposta não 202. Para obter mais informações, consulte A integração assíncrona de microsserviços impõe a autonomia do microsserviço.
No Logic App Designer, a ação HTTP, as ações APIConnection e a ação Response têm a configuração Padrão assíncrono. Quando habilitada, essa configuração especifica que o chamador não espera a conclusão do processamento e pode passar para a próxima ação, mas continua verificando o status até que o processamento pare. Se desabilitada, essa configuração especifica que o chamador aguarda a conclusão do processamento antes de passar para a próxima ação. Para localizar esta definição, siga estes passos:
Na barra de título da ação HTTP, selecione o botão de reticências (...), que abre as configurações da ação.
Encontre a configuração Padrão assíncrono.
Na definição subjacente de JavaScript Object Notation (JSON) da ação, a ação HTTP e as ações APIConnection seguem implicitamente o padrão de operação assíncrona.
Em alguns cenários, talvez você queira que uma ação siga o padrão síncrono. Por exemplo, quando você usa a ação HTTP, talvez queira:
- Evite tempos limite HTTP para tarefas de longa execução
- Desativar a verificação de cabeçalhos de localização
Nesses casos, você pode executar uma ação de forma síncrona usando estas opções:
Substitua a versão de sondagem dessa ação por uma versão de webhook, se disponível.
Desative o comportamento assíncrono da ação seguindo uma das opções:
No Logic App Designer, desative a configuração Padrão assíncrono.
Na definição JSON subjacente da ação, adicione a
"DisableAsyncPattern"opção de operação.
Desativar a configuração Padrão assíncrono
No Logic App Designer, na barra de título da ação, selecione o botão de reticências (...), que abre as configurações da ação.
Encontre a configuração Padrão assíncrono, ative a configuração para Desativado, se habilitada, e selecione Concluído.
Desabilitar padrão assíncrono na definição JSON da ação
Na definição JSON subjacente da ação, adicione e defina a propriedade "operationOptions" na "DisableAsyncPattern" seção da "inputs" ação, por exemplo:
"<some-long-running-action>": {
"type": "Http",
"inputs": { "<action-inputs>" },
"operationOptions": "DisableAsyncPattern",
"runAfter": {}
}
Autenticar gatilhos e ações
Os pontos de extremidade HTTP e HTTPS suportam diferentes tipos de autenticação. Com base no gatilho ou ação que você usa para fazer chamadas de saída ou solicitações para acessar esses pontos de extremidade, você pode selecionar entre diferentes intervalos de tipos de autenticação. Para obter mais informações, consulte Adicionar autenticação a chamadas de saída.
Próximos passos
- Saiba mais sobre a Linguagem de Definição de Fluxo de Trabalho