Справочник по схемам для типов триггеров и действий в Azure Logic Apps

Этот справочник описывает общие типы, используемые для идентификации триггеров и действий в базовом определении рабочего процесса приложения логики, которое описывается и проверяется с помощью языка определения рабочего процесса. To find specific connector triggers and actions that you can use in your logic apps, see the list under the Connectors overview.

Triggers overview

Каждый рабочий процесс включает триггер, который определяет вызовы, создающие экземпляры и запускающие рабочий процесс. Ниже приведены общие категории триггеров.

• A polling trigger, which checks a service's endpoint at regular intervals

• A push trigger, which creates a subscription to an endpoint and provides a callback URL so the endpoint can notify the trigger when the specified event happens or data is available. Затем триггер ожидает ответа конечной точки, прежде чем сработать.

Триггеры имеют следующие основные элементы, хотя некоторые из них являются необязательными.

"<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>"
},

Required

Optional

Список типов триггеров

Каждый тип триггера имеет свой интерфейс и свои входные данные, которые определяют его поведение.

Built-in triggers

Управляемые триггеры API

Триггеры. Подробная справочная информация

APIConnection trigger

This trigger checks or polls an endpoint by using Microsoft-managed APIs or "connectors" so the parameters for this trigger can differ based on the endpoint. Многие разделы в этом определении триггера являются необязательными. Режим работы триггера зависит от того, включены ли разделы.

"<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>"
}

Required

Optional

Outputs

Example

Следующее определение триггера каждый день проверяет электронную почту в папке "Входящие" для рабочей или учебной учетной записи:

"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 trigger

This trigger sends a subscription request to an endpoint by using a Microsoft-managed API, provides a callback URL to where the endpoint can send a response, and waits for the endpoint to respond. For more information, see Endpoint subscriptions.

"<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>"
}

Required

Optional

Example

Это определение триггера подписывается на API Office 365 Outlook, предоставляет URL-адрес обратного вызова на конечную точку API и ожидает ответа конечной точки при получении нового электронного письма.

"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']"
}

HTTP trigger

Этот триггер отправляет запрос в указанную конечную точку HTTP или HTTPS на основе указанного расписания повторения. Затем триггер проверяет ответ, чтобы определить, выполняется ли рабочий процесс. Дополнительные сведения см. в статье Вызов конечных точек по протоколу HTTP или HTTPS через Azure Logic Apps.

"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>"
}

Required

Optional

Outputs

Требования для входящих запросов

Для качественной работы с приложением логики конечная точка должна соответствовать определенному шаблону или условию триггера, а также распознавать следующие свойства:

Пример поведения для различных запросов

HTTPWebhook trigger

Этот триггер делает приложение логики вызываемым, создавая конечную точку, которая может зарегистрировать подписку путем вызова URL-адреса указанной конечной точки. При создании этого триггера в рабочем процессе исходящий запрос выполняет вызов для регистрации подписки. Таким образом, триггер может запустить ожидание событий. Когда операция делает этот триггер недопустимым, исходящий запрос автоматически выполняет вызов для отмены подписки. For more information, see Endpoint subscriptions.

You can also specify asynchronous limits on an HTTPWebhook trigger. Поведение триггера зависит от разделов, которые используются или пропускаются.

"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>"
}

Some values, such as <method-type>, are available for both the "subscribe" and "unsubscribe" objects.

Required

Optional

Outputs

Example

Этот триггер создает подписку на указанную конечную точку, предоставляет уникальный URL-адрес обратного вызова и ожидает новых публикаций технологических статей.

"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"
         }
      }
   }
}

Recurrence trigger

Этот триггер выполняется на основе указанного расписания повторов и предоставляет простой способ создания регулярно запускающегося рабочего процесса.

"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>"
}

Required

Optional

Example 1

Этот основной триггер повторения запускается ежедневно:

"Recurrence": {
   "type": "Recurrence",
   "recurrence": {
      "frequency": "Day",
      "interval": 1
   }
}

Example 2

Вы можете задать дату и время, когда триггер будет срабатывать. Этот триггер повторения будет запущен в соответствии с указанной датой, а затем будет срабатывать ежедневно:

"Recurrence": {
   "type": "Recurrence",
   "recurrence": {
      "frequency": "Day",
      "interval": 1,
      "startTime": "2017-09-18T00:00:00Z"
   }
}

Example 3

Этот триггер повторения был запущен 9 сентября 2017 года в 14:00 и запускался каждый понедельник в 10:30, 12:30 и 14:30 по тихоокеанскому времени:

"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"
   }
}

Дополнительные сведения, а также примеры это триггера см. в статье Создание и планирование регулярно выполняющихся задач при помощи Azure Logic Apps.

Request trigger

Этот триггер делает приложение логики вызываемым, создавая конечную точку, которая может принимать входящие запросы. Предоставьте схему JSON для этого триггера, которая описывает и проверяет полезные или входные данные, которые триггер получает от входящего запроса. Схема также упрощает свойства триггеров для ссылки на следующие действия в рабочем процессе.

Чтобы вызвать этот триггер, необходимо использовать API listCallbackUrl, описанный в REST API службы рабочих процессов. Чтобы узнать, как использовать этот триггер в качестве конечной точки HTTP, см. сведения в статье Вызовы, срабатывания триггеров и создание вложенных рабочих процессов в приложениях логики.

"Request": {
   "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>"
}

Required

Optional

Example

Этот триггер указывает, что входящий запрос должен использовать HTTP-метод POST для вызова триггера, а также включать схему, проверяющую входные данные входящего запроса.

"Request": {
   "type": "Request",
   "kind": "Http",
   "inputs": {
      "method": "POST",
      "schema": {
         "type": "object",
         "properties": {
            "customerName": {
               "type": "String"
            },
            "customerAddress": { 
               "type": "Object",
               "properties": {
                  "streetAddress": {
                     "type": "string"
                  },
                  "city": {
                     "type": "string"
                  }
               }
            }
         }
      }
   }
}

Trigger conditions

Для любого триггера (или только для триггера) можно включить массив, содержащий одно или несколько выражений для условий, определяющих, следует ли запускать рабочий процесс. Чтобы добавить к приложению логики свойство conditions, откройте приложение в редакторе представления кода.

Например, можно указать, что триггер срабатывает, только если веб-сайт возвращает внутреннюю ошибку сервера, ссылаясь на код состояния триггера в свойстве conditions.

"Recurrence": {
   "type": "Recurrence",
   "recurrence": {
      "frequency": "Hour",
      "interval": 1
   },
   "conditions": [ {
      "expression": "@equals(triggers().code, 'InternalServerError')"
   } ]
}

По умолчанию триггер срабатывает только после получения ответа "200 OK". Если выражение ссылается на код состояния триггера, стандартный режим работы триггера изменяется. Таким образом, если требуется запуск триггера при более чем одном коде состояния, например "200" и "201", необходимо включить в качестве условия следующее выражение.

@or(equals(triggers().code, 200),equals(triggers().code, 201))

Активация нескольких запусков в массиве

Если триггер получает массив для обработки рабочим процессом, цикл for each иногда может занимать слишком много времени для обработки каждого элемента массива. Instead, you can use the SplitOn property in your trigger to debatch the array. При индивидуальной обработке массив разделяется на элементы и для каждого элемента запускается новый экземпляр рабочего процесса. Такой подход является эффективным, например, если нужно опросить конечную точку, которая может вернуть несколько новых элементов между интервалами опроса.

If your trigger's Swagger file describes a payload that's an array, the SplitOn property is automatically added to your trigger. В противном случае добавьте это свойство в полезные данные ответа, содержащий массив, который нужно обработать индивидуально.

Прежде чем использовать функцию SplitOn, ознакомьтесь со следующими рекомендациями.

• If trigger concurrency is enabled, the SplitOn limit is significantly reduced. Если число элементов превышает это ограничение, функция SplitOn отключается.

• Функцию SplitOn нельзя использовать с шаблоном синхронного отклика. Any workflow that uses the SplitOn property and includes a response action runs asynchronously and immediately sends a 202 ACCEPTED response.

• For the maximum number of array items that SplitOn can process in a single workflow run, see Limits and configuration.

Example

Предположим, что у вас есть триггер HTTP, который вызывает API и получает следующий ответ:

{
   "Status": "Succeeded",
   "Rows": [ 
      { 
         "id": 938109380,
         "name": "customer-name-one"
      },
      {
         "id": 938109381,
         "name": "customer-name-two"
      }
   ]
}

Рабочему процессу требуется только содержимое массива в Rows, поэтому можно создать триггер, как в следующем примере.

"HTTP_Debatch": {
   "type": "Http",
    "inputs": {
        "uri": "https://mydomain.com/myAPI",
        "method": "GET"
    },
   "recurrence": {
      "frequency": "Second",
      "interval": 1
    },
    "splitOn": "@triggerBody()?.Rows"
}

Теперь в определении рабочего процесса можно использовать @triggerBody().name, чтобы получить значения name, которые являются значениями "customer-name-one" при первом выполнении и "customer-name-two" при втором выполнении. Выходные данные триггера выглядят так:

{
   "body": {
      "id": 938109380,
      "name": "customer-name-one"
   }
}

{
   "body": {
      "id": 938109381,
      "name": "customer-name-two"
   }
}

Actions overview

Azure Logic Apps предоставляет различные типы действий. Каждый из них имеет различные входные данные, которые определяют уникальный режим работы действия. Действия включают следующие основные элементы, хотя некоторые из них являются необязательными.

"<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>"
},

Required

Optional

Список типов действий

Некоторые часто используемые типы действий.

• Встроенные типы действий, такие как нижеприведенные примеры и многое другое.

  • HTTP for calling endpoints over HTTP or HTTPS

  • Response for responding to requests

  • Запуск кода JavaScript для выполнения фрагментов кода JavaScript

  • Function for calling Azure Functions

  • Data operation actions such as Join, Compose, Table, Select, and others that create or transform data from various inputs

  • Workflow for calling another logic app workflow

• Типы действий управляемых API, такие как ApiConnection и ApiConnectionWebHook, которые вызывают различные соединители и управляемые Майкрософт интерфейсы API, например Служебная шина Azure, Office 365 Outlook, Power BI, хранилище BLOB-объектов Azure, OneDrive, GitHub и т. д.

• Типы действий рабочего процесса управления, такие как If, Foreach, Switch, Scope и Until, которые содержат другие действия и помогают организовать выполнение рабочего процесса

Built-in actions

Действия управляемых API

Действия рабочего процесса управления

Эти действия позволяют управлять выполнением рабочего процесса и включают в себя другие действия. За пределами действия рабочего процесса управления можно непосредственно ссылаться на действия внутри него. Например, если имеется действие Http внутри области, можно ссылаться на выражение @body('Http') из любой точки в рабочем процессе. В то же время действия, которые существуют внутри действия рабочего процесса управления, могут "привязываться" только к другим действиям, которые находятся в той же структуре рабочего процесса управления.

Действия. Подробная справочная информация

APIConnection action

This action sends an HTTP request to a Microsoft-managed API and requires information about the API and parameters plus a reference to a valid connection.

"<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": {}
}

Required

Optional

Example

Это определение описывает действие Отправить по электронной почте для соединителя Outlook Office 365, который является управляемым Майкрософт интерфейсом API.

"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": {}
}

APIConnectionWebhook action

This action sends a subscription request over HTTP to an endpoint by using a Microsoft-managed API, provides a callback URL to where the endpoint can send a response, and waits for the endpoint to respond. For more information, see Endpoint subscriptions.

"<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": {}
}

Some values, such as <method-type>, are available for both the "subscribe" and "unsubscribe" objects.

Required

Optional

You can also specify limits on an ApiConnectionWebhook action in the same way as HTTP asynchronous limits.

Compose action

Это действие создает один вывод из нескольких входных данных, включая выражения. Оба входа и выхода могут иметь любой тип, поддерживаемый Azure Logic Apps, например массивы, объекты JSON, язык XML и двоичные объекты. Затем можно использовать выходные данные действия в других действиях.

"Compose": {
   "type": "Compose",
   "inputs": "<inputs-to-compose>",
   "runAfter": {}
},

Required

Example 1

Это определение действия объединяет abcdefg с конечным пространством и значением 1234.

"Compose": {
   "type": "Compose",
   "inputs": "abcdefg 1234",
   "runAfter": {}
},

Результат, который создает это действие:

abcdefg 1234

Example 2

Это определение действия объединяет строковую переменную, содержащую abcdefg и целочисленную переменную, которая содержит 1234.

"Compose": {
   "type": "Compose",
   "inputs": "@{variables('myString')}@{variables('myInteger')}",
   "runAfter": {}
},

Результат, который создает это действие:

"abcdefg1234"

Execute JavaScript Code action (Выполнить действие кода JavaScript)

Это действие выполняет фрагмент кода JavaScript и возвращает результаты через маркер, на который могут ссылаться дальнейшие действия.

"Execute_JavaScript_Code": {
   "type": "JavaScriptCode",
   "inputs": {
      "code": "<JavaScript-code-snippet>",
      "explicitDependencies": {
         "actions": [ <preceding-actions> ],
         "includeTrigger": true
      }
   },
   "runAfter": {}
}

Required

Необходимо в некоторых случаях

Атрибут explicitDependencies указывает, что необходимо явно включить результаты из триггера, предыдущих действий, или всего вышеперечисленного, в качестве зависимостей для фрагмента кода. Дополнительные сведения о добавлении этих зависимостей см. в разделе Добавление зависимостей в качестве параметров в действие встроенного кода.

Для атрибута includeTrigger можно указать значения true или false.

Example 1

Это действие запускает код, который получает имя рабочего процесса приложения логики и возвращает в результате текст "Hello world from <имя-приложения-логики>". В этом примере код ссылается на имя рабочего процесса, обращаясь к свойству workflowContext.workflow.name через объект workflowContext, который доступен только для чтения. Дополнительные сведения об объекте workflowContext см. в разделе Эталонный триггер и результаты действия в коде.

"Execute_JavaScript_Code": {
   "type": "JavaScriptCode",
   "inputs": {
      "code": "var text = \"Hello world from \" + workflowContext.workflow.name;\r\n\r\nreturn text;"
   },
   "runAfter": {}
}

Example 2

Это действие запускает код в рабочем процессе приложении логики, которое активируется при поступлении нового электронного письма в учетную запись Outlook. Рабочий процесс также использует действие отправки утверждения по электронной почте Office 365 Outlook, которое пересылает содержимое из полученного электронного письма вместе с запросом на утверждение.

Код извлекает адреса электронной почты из свойства электронного сообщения Body и возвращает адреса вместе со значением свойства SelectedOption из действия утверждения. Действие явным образом включает действие отправки утверждения по электронной почте в качестве actions объекта внутри explicitDependencies объекта.

"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": {}
}

Function action

This action calls a previously created Azure function.

"<Azure-function-name>": {
   "type": "Function",
   "inputs": {
     "function": {
        "id": "<Azure-function-ID>"
      },
      "method": "<method-type>",
      "headers": { "<header-content>" },
      "body": { "<body-content>" },
      "queries": { "<query-parameters>" } 
   },
   "runAfter": {}
}

Required

Optional

При сохранении приложения логики Azure Logic Apps выполняет следующие проверки для указанной функции:

• У рабочего процесса должен быть доступ к функции.

• Рабочий процесс может использовать только стандартный триггер HTTP или универсальный триггер веб-перехватчика в формате JSON.

  Azure Logic Apps получает и кэширует URL-адрес триггера, который используется во время выполнения. However, if any operation invalidates the cached URL, the Function action fails at runtime. Чтобы устранить эту проблему, повторно сохраните приложение логики, чтобы оно снова загрузило URL-адрес триггера.

• Функция не может иметь какой-либо определенный маршрут.

• Можно использовать только авторизацию с помощью функции и анонимную авторизацию.

Example

Это определение действия вызывает ранее созданную функцию GetProductID.

"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": {}
}

HTTP action

Это действие отсылает запрос на указанную конечную точку HTTP или HTTPS и по результату проверки определяет, следует ли запускать рабочий процесс. Дополнительные сведения см. в статье Вызов конечных точек по протоколу HTTP или HTTPS через Azure Logic Apps.

"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": {}
}

Required

Optional

Example

Это определение действия получает последние новости, отправив запрос на указанную конечную точку.

"HTTP": {
   "type": "Http",
   "inputs": {
      "method": "GET",
      "uri": "https://mynews.example.com/latest"
   }
}

Join action

Это действие создает строку из всех элементов в массиве и разделяет эти элементы определенным символом разделителя.

"Join": {
   "type": "Join",
   "inputs": {
      "from": <array>,
      "joinWith": "<delimiter>"
   },
   "runAfter": {}
}

Required

Example

Предположим, что у вас есть ранее созданная переменная myIntegerArray, содержащая этот массив целых чисел.

[1,2,3,4]

Это определение действия получает значения из переменной с помощью функции variables() в выражении и создает эту строку с теми значениями, которые разделяются запятыми: "1,2,3,4".

"Join": {
   "type": "Join",
   "inputs": {
      "from": "@variables('myIntegerArray')",
      "joinWith": ","
   },
   "runAfter": {}
}

Действие "Анализ JSON"

This action creates user-friendly fields or tokens from the properties in JSON content. Затем можно получить доступ к этим свойствам в своем приложении логики, используя вместо этого токены. Например, если необходимо использовать выходные данные JSON таких служб как Служебная шина Azure и Azure Cosmos DB, можно включить это действие в своем приложении логики, чтобы иметь возможность легче ссылаться на выходные данные.

"Parse_JSON": {
   "type": "ParseJson",
   "inputs": {
      "content": "<JSON-source>",
         "schema": { "<JSON-schema>" }
      },
      "runAfter": {}
},

Required

Example

This action definition creates these tokens that you can use in your workflow but only in actions that run following the Parse JSON action:

FirstName, LastName и 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": { }
},

В этом примере свойство content указывает содержимое JSON для анализа. Также можно предоставить это содержимое JSON как пример полезных данных для создания схемы.

"content": {
   "Member": { 
      "FirstName": "Sophie",
      "LastName": "Owen",
      "Email": "Sophie.Owen@contoso.com"
   }
},

Свойство schema указывает схему JSON, используемую для описания содержимого JSON.

"schema": {
   "type": "object",
   "properties": {
      "Member": {
         "type": "object",
         "properties": {
            "FirstName": {
               "type": "string"
            },
            "LastName": {
               "type": "string"
            },
            "Email": {
               "type": "string"
            }
         }
      }
   }
}

Query action

Это действие создает массив из элементов другого массива на основании указанного условия или фильтра.

"Filter_array": {
   "type": "Query",
   "inputs": {
      "from": <array>,
      "where": "<condition-or-filter>"
   },
   "runAfter": {}
}

Required

Example

Это определение действия создает массив, содержащий значения, превышающие указанное значение, которое равно двум.

"Filter_array": {
   "type": "Query",
   "inputs": {
      "from": [ 1, 3, 0, 5, 4, 2 ],
      "where": "@greater(item(), 2)"
   }
}

Response action

Это действие создает полезные данные для ответа на запрос HTTP.

"Response" {
    "type": "Response",
    "kind": "http",
    "inputs": {
        "statusCode": 200,
        "headers": { <response-headers> },
        "body": { <response-body> }
    },
    "runAfter": {}
},

Required

Optional

Example

Это определение действия создает ответ на HTTP-запрос с заданным кодом статуса, текстом сообщения и заголовком сообщения.

"Response": {
   "type": "Response",
   "inputs": {
      "statusCode": 200,
      "body": {
         "ProductID": 0,
         "Description": "Organic Apples"
      },
      "headers": {
         "x-ms-date": "@utcnow()",
         "content-type": "application/json"
      }
   },
   "runAfter": {}
}

Restrictions

Unlike other actions, the Response action has special restrictions:

• Your workflow can use the Response action only when the workflow starts with an HTTP request trigger, meaning your workflow must be triggered by an HTTP request.

• Your workflow can use the Response action anywhere except inside Foreach loops, Until loops, including sequential loops, and parallel branches.

• The original request gets your workflow's response only when all actions required by the Response action are finished within the HTTP timeout limit.

  Однако, если рабочий процесс вызывает другое приложение логики в качестве вложенного рабочего процесса, родительский рабочий процесс ожидает завершения вложенного рабочего процесса, независимо от того, сколько времени прошло до его завершения.

• When your workflow uses the Response action and a synchronous response pattern, the workflow can't also use the splitOn command in the trigger definition because that command creates multiple runs. Проверьте этот случай, когда используется метод PUT, и если значение равно true, вернется ответ "Недопустимый запрос".

  Otherwise, if your workflow uses the splitOn command and a Response action, the workflow runs asynchronously and immediately returns a "202 ACCEPTED" response.

• When your workflow's execution reaches the Response action, but the incoming request has already received a response, the Response action is marked as "Failed" due to the conflict. И в результате выполнения приложения логики также отмечается состояние Failed (Сбой).

Select action

Это действие создает массив с объектами JSON путем преобразования элементов из другого массива на основе указанного сопоставления. Выходной и исходный массив всегда имеет одинаковое количество элементов. Несмотря на то что невозможно изменить количество объектов в выходном массиве, можно добавлять или удалять свойства и их значения в этих объектах. Свойство select указывает по меньшей мере одну пару "ключ — значение", определяющую сопоставление для преобразования элементов в исходном массиве. Пара "ключ — значение" представляет свойство и его значение во всех объектах выходного массива.

"Select": {
   "type": "Select",
   "inputs": {
      "from": <array>,
      "select": { 
          "<key-name>": "<expression>",
          "<key-name>": "<expression>"        
      }
   },
   "runAfter": {}
},

Required

The Select action creates an array as output, so any action that wants to use this output must either accept an array, or you must convert the array into the type that the consumer action accepts. For example, to convert the output array to a string, you can pass that array to the Compose action, and then reference the output from the Compose action in your other actions.

Example

Это определение действия создает массив объектов JSON из массива целых чисел. Действие повторяется с исходным массивом, получает каждое целочисленное значение с помощью выражения @item() и присваивает каждому значению свойство "number" в каждом объекте JSON.

"Select": {
   "type": "Select",
   "inputs": {
      "from": [ 1, 2, 3 ],
      "select": { 
         "number": "@item()" 
      }
   },
   "runAfter": {}
},

Массив, который создает это действие.

[ { "number": 1 }, { "number": 2 }, { "number": 3 } ]

To use this array output in other actions, pass this output into a Compose action:

"Compose": {
   "type": "Compose",
   "inputs": "@body('Select')",
   "runAfter": {
      "Select": [ "Succeeded" ]
   }
},

You can then use the output from the Compose action in your other actions, for example, the Office 365 Outlook - Send an email action:

"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" ]
   }
},

Table action

Это действие создает таблицу CSV или HTML из массива. Для массивов с объектами JSON это действие автоматически создает заголовки столбцов с именами свойств объектов. Для массивов с другими типами данных необходимо указать заголовки столбцов и значений. Например, этот массив содержит свойства ID и Product_Name, которые могут использовать это действие для заголовков столбцов.

[ {"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": {}
}

Required

Optional

Чтобы задать или настроить заголовки столбцов и значения, используйте массив columns. Когда пары header-value имеют одинаковое имя заголовка, их значения отображаются в том же столбце под этим заголовком. В противном случае каждый уникальный заголовок определяет уникальный столбец.

Example 1

Предположим, что имеется ранее созданная переменная myItemArray, содержащая в данный момент этот массив.

[ {"ID": 0, "Product_Name": "Apples"}, {"ID": 1, "Product_Name": "Oranges"} ]

Это определение действия создает таблицу CSV из переменной myItemArray. Выражение, использующее свойство from, возвращает массив из myItemArray с помощью функции variables().

"Create_CSV_table": {
   "type": "Table",
   "inputs": {
      "format": "CSV",
      "from": "@variables('myItemArray')"
   },
   "runAfter": {}
}

Таблица CSV, которая создает это действие.

ID,Product_Name 
0,Apples 
1,Oranges 

Example 2

Это определение действия создает таблицу HTML из переменной myItemArray. Выражение, использующее свойство from, возвращает массив из myItemArray с помощью функции variables().

"Create_HTML_table": {
   "type": "Table",
   "inputs": {
      "format": "HTML",
      "from": "@variables('myItemArray')"
   },
   "runAfter": {}
}

Таблица HTML, которую создает это действие:

Example 3

Это определение действия создает таблицу HTML из переменной myItemArray. Однако этот пример переопределяет имена заголовков столбцов по умолчанию с помощью Stock_ID и Description и добавляет слово Organic к значениям в столбце 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": {}
},

Таблица HTML, которую создает это действие:

Terminate action

Это действие останавливает выполнение экземпляра рабочего процесса, отменяет все выполняемые действия, пропуская все оставшиеся действия, и возвращает указанное состояние. For example, you can use the Terminate action when your logic app must exit completely from an error state. This action doesn't affect already completed actions and can't appear inside Foreach and Until loops, including sequential loops.

"Terminate": {
   "type": "Terminate",
   "inputs": {
       "runStatus": "<status>",
       "runError": {
            "code": "<error-code-or-name>",
            "message": "<error-message>"
       }
   },
   "runAfter": {}
}

Required

Optional

Свойства объекта runError применяются только в том случае, если для свойства runStatus задано состояние "Failed".

Example

Это определение действия останавливает выполнение рабочего процесса, устанавливает статус запуска как Failed (Сбой) и возвращает состояние, код ошибки и сообщение об ошибке.

"Terminate": {
    "type": "Terminate",
    "inputs": {
        "runStatus": "Failed",
        "runError": {
            "code": "Unexpected response",
            "message": "The service received an unexpected response. Please try again."
        }
   },
   "runAfter": {}
}

Wait action

Это действие приостанавливает выполнение рабочего процесса на указанный период времени или до указанного времени, но не для обоих.

Specified interval

"Delay": {
   "type": "Wait",
   "inputs": {
      "interval": {
         "count": <number-of-units>,
         "unit": "<interval>"
      }
   },
   "runAfter": {}
},

Specified time

"Delay_until": {
   "type": "Wait",
   "inputs": {
      "until": {
         "timestamp": "<date-time-stamp>"
      }
   },
   "runAfter": {}
},

Required

Example 1

Это определение действия приостанавливает рабочий процесс на 15 минут.

"Delay": {
   "type": "Wait",
   "inputs": {
      "interval": {
         "count": 15,
         "unit": "Minute"
      }
   },
   "runAfter": {}
},

Example 2

Это определение действия приостанавливает рабочий процесс до указанного времени.

"Delay_until": {
   "type": "Wait",
   "inputs": {
      "until": {
         "timestamp": "2017-10-01T00:00:00Z"
      }
   },
   "runAfter": {}
},

Workflow action

Это действие вызывает другое ранее созданное приложение логики, это значит, что можно включать и повторно использовать другие рабочие процессы приложений логики. You can also use the outputs from the child or nested logic app in actions that follow the nested logic app, provided that the child logic app returns a response.

Azure Logic Apps проверяет доступ к триггеру, который требуется вызвать, поэтому убедитесь, что вы можете получить доступ к триггеру. Кроме того, вложенное приложение логики должно соответствовать следующим критериям.

• A trigger makes the nested logic app callable, such as a Request or HTTP trigger

• Та же подписка Azure, что и родительское приложение логики

• To use the outputs from the nested logic app in your parent logic app, the nested logic app must have a Response action

"<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": {}
}

Required

Optional

Outputs

Выходные данные этого действия различаются в зависимости от действия "Ответ" вложенного приложения логики. Если вложенное приложение логики не включает действие "Ответ", выходные данные будут пустыми.

Example

После успешного завершения действия Start_search это определение действия рабочего процесса вызывает другое приложение логики с именем Get_product_information, которое передается в заданные входы.

"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" ]
      }
   }
},

Сведения о действиях рабочего процесса управления

Foreach action

Это циклическое действие выполняет итерацию по массиву и действия с каждым элементом массива. По умолчанию цикл Foreach выполняется в параллельном режиме, вплоть до максимального числа циклов. Это максимальное значение указано в разделе Ограничения и конфигурация. Узнайте также, как создавать циклы "for each".

"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>"
}

Required

Optional

Example

Этот цикл Foreach отправляет электронное письмо для каждого элемента массива, содержащего вложения из входящего письма. Цикл отправляет электронное письмо, включая вложение, пользователю, который рассматривает вложение.

"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": {}
}

To specify only an array that is passed as output from the trigger, this expression gets the <array-name> array from the trigger body. Чтобы избежать ошибок при отсутствии массива, в этом выражении используется оператор ?.

@triggerBody()?['<array-name>']

If action

This action, which is a conditional statement, evaluates an expression that represents a condition and runs a different branch based on whether the condition is true or false. Если условие истинное, ему будет присвоено состояние Succeeded (Успешно). Дополнительные сведения см. в разделе Создание условных операторов, которые управляют действиями в рабочих процессах Azure Logic Apps.

"Condition": {
   "type": "If",
   "expression": { "<condition>" },
   "actions": {
      "<action-1>": { "<action-definition>" }
   },
   "else": {
      "actions": {
        "<action-2>": { "<action-definition" }
      }
   },
   "runAfter": {}
}

Действия в объектах actions или else получают следующие статусы.

• "Succeeded", если они запускаются и выполняются успешно;
• "Failed", если они запускаются, но завершаются ошибкой;
• "Skipped", если не запускается соответствующая ветвь.

Example

Это условие указывает, что когда целочисленная переменная имеет значение больше нуля, рабочий процесс проверяет веб-сайт. Если переменная равна нулю или меньше, рабочий процесс проверяет другой веб-сайт.

"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": {}
}

Использование выражений условиями

Ниже приведены некоторые примеры, показывающие, как можно использовать выражения в условиях.

Scope action

This action logically groups actions into scopes, which get their own status after the actions in that scope finish running. Затем можно использовать статус области, чтобы определить, выполняются ли другие действия. Дополнительные сведения см. в разделе Создание областей, которые выполняют действия рабочего процесса на основе состояния группы в Azure Logic Apps.

"Scope": {
   "type": "Scope",
   "actions": {
      "<inner-action-1>": {
         "type": "<action-type>",
         "inputs": { "<action-inputs>" },
         "runAfter": {}
      },
      "<inner-action-2>": {
         "type": "<action-type>",
         "inputs": { "<action-inputs>" },
         "runAfter": {}
      }
   }
}

Required

Switch action

This action, also known as a switch statement, organizes other actions into cases, and assigns a value to each case, except for the default case if one exists. When your workflow runs, the Switch action compares the value from an expression, object, or token against the values specified for each case. If the Switch action finds a matching case, your workflow runs only the actions for that case. Each time the Switch action runs, either only one matching case exists or no matches exist. If no matches exist, the Switch action runs the default actions. Дополнительные сведения см. в разделе Создание операторов switch, которые запускают действия рабочего процесса на основе определенных значений в Azure Logic Apps.

"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": {}
}

Required

Optional

Example

Это определение действия оценивает, выбирает ли пользователь в ответ на письмо с запросом вариант "Утвердить" или "Отклонить". Based on this choice, the Switch action runs the actions for the matching case, which is to send another email to the responder but with different wording in each case.

"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"
      ]
   }
}

Until action

Это действие цикла содержит действия, которые выполняются, пока указанное условие имеет истинное значение. После завершения работы всех других действий на последнем этапе цикл проверяет условие. Можно включить несколько действий в объект "actions", и действие должно определить как минимум одно ограничение. Дополнительные сведения см. в разделе Цикл until.

 "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": {}
}

Example

Это определение действия цикла отправляет HTTP-запрос по указанному URL-адресу до тех пор, пока не будет выполнено одно из этих условий.

• Запрос возвращает ответ с состоянием кода "200 OK".
• Цикл выполнялся 60 раз.
• Цикл был выполнен в течение одного часа.

 "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": {}
}

Веб-перехватчики и подписки

Триггеры и действия на основе веб-перехватчика не регулярно проверяют конечные точки, но ждут конкретных событий или данных на этих конечных точках. These triggers and actions subscribe to the endpoints by providing a callback URL where the endpoint can send responses.

Вызов subscribe выполняется при любом изменении рабочего процесса, например когда происходит обновление учетных данных или изменяются входные параметры для триггера или действия. Этот вызов использует те же параметры, что и стандартные действия HTTP.

Вызов unsubscribe выполняется автоматически, когда при выполнении операции триггер или действие становится недопустимым, например:

• удаление или отключение триггера;
• удаление или отключение рабочего процесса;
• удаление или отключение подписки.

Для поддержки этих вызовов выражение @listCallbackUrl() возвращает уникальный "URL-адрес обратного вызова" для этого триггера или действия. Этот URL-адрес представляет собой уникальный идентификатор для конечных точек, использующих REST API службы. Параметры этой функции совпадают с параметрами триггера веб-перехватчика или действия.

Изменение асинхронной длительности

Для триггеров и действий можно ограничить длительность для асинхронного шаблона определенным интервалом времени, добавив свойство limit.timeout. Таким образом, если действие не закончилось, когда интервал истекает, статус действия помечается Cancelled с кодом ActionTimedOut. Свойство timeout использует формат ISO 8601.

"<trigger-or-action-name>": {
   "type": "Workflow | Webhook | Http | ApiConnectionWebhook | ApiConnection",
   "inputs": {},
   "limit": {
      "timeout": "PT10S"
   },
   "runAfter": {}
}

Параметры конфигурации среды выполнения

Вы можете изменить поведение среды выполнения по умолчанию для триггеров и действий путем добавления свойств runtimeConfiguration в триггер или определение действия.

Operation options

Можно изменить поведение по умолчанию для триггеров и действий со свойством operationOptions в триггере или определении действия.

Изменение параллелизма триггера

По умолчанию экземпляры рабочего процесса запускаются одновременно или параллельно. Это означает, что каждый экземпляр триггера срабатывает до завершения выполнения предыдущего экземпляра рабочего процесса. However, the number of concurrently running instances has a default limit. Когда количество одновременно выполняемых экземпляров рабочего процесса достигает этого предела, все остальные экземпляры должны ожидать выполнения. Это ограничение помогает контролировать количество запросов, которые получают серверные системы.

When you turn on the trigger's concurrency control, trigger instances run in parallel up to the default limit. Чтобы изменить это ограничение параллелизма по умолчанию, можно использовать редактор представления кода или конструктор рабочих процессов, так как изменение параметра параллелизма с помощью конструктора добавляет или обновляет runtimeConfiguration.concurrency.runs свойство в базовом определении триггера и наоборот. Это свойство определяет максимальное число экземпляров рабочего процесса, которые могут выполняться параллельно.

Прежде чем включить параллелизм для триггера, ознакомьтесь со следующими рекомендациями.

• После включения управления параллелизмом его невозможно будет отключить.

• Если максимальное число параллельных запусков триггера достигает максимальной степени параллелизма, последующие запуски триггера могут вызвать регулирование или ошибки "429 — слишком много запросов". Если вы настроили политику повторных попыток, которая обрабатывает ошибки 429, триггер может вызвать цикл повтора и регулирования, что приведет к длительным задержкам при обработке новых запросов триггеров.

• When concurrency is enabled, the SplitOn limit is significantly reduced for debatching arrays. Если число элементов превышает это ограничение, функция SplitOn отключается.

• При включении параллелизма долго выполняющийся экземпляр приложения логики может привести к тому, что новые экземпляры приложения логики будут входить в состояние ожидания. Это состояние предотвращает создание новых экземпляров Azure Logic Apps и происходит даже в том случае, если количество параллельных запусков меньше указанного максимального числа параллельных запусков.

  • To interrupt this state, cancel the earliest instances that are still running.

    1. On your logic app's menu, select Overview.

    2. In the Runs history section, select the earliest instance that is still running, for example:

       

       Tip

       To view only instances that are still running, open the All list, and select Running.

    3. В разделе Выполнение приложения логики щелкните Отменить выполнение.

       

  • Чтобы обойти эту возможность, добавьте время ожидания для любого действия, которое может содержать эти запуски. Если вы работаете в редакторе кода, см. раздел Изменение длительности асинхронного выполнения. В другом случае, если вы используете конструктор, выполните следующие действия.

    1. В рабочем процессе приложения логики выберите действие, в которое нужно добавить время ожидания. In the action's upper-right corner, select the ellipses (...) button, and then select Settings.

       

    2. Under Timeout, specify the timeout duration in ISO 8601 format.

       

• Для последовательного запуска приложения логики задайте для параллелизма триггера значение 1 либо с помощью редактора представления кода, либо конструктора. Убедитесь, что для свойства триггера operationOptions в редакторе представления кода не задано значение SingleInstance. В противном случае возникнет ошибка проверки. Дополнительные сведения см. в разделе Последовательная активизация экземпляров.

Изменение в представлении кода

В определении базового триггера добавьте свойство runtimeConfiguration.concurrency.runs и задайте значение в зависимости от ограничений параллелизма триггера. Для последовательного запуска рабочего процесса задайте для свойства значение 1.

Этот пример ограничивает число параллельных запусков до 10 экземпляров:

"<trigger-name>": {
   "type": "<trigger-name>",
   "recurrence": {
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>,
   },
   "runtimeConfiguration": {
      "concurrency": {
         "runs": 10
      }
   }
}

Дополнительные сведения см. в разделе Настройки конфигурации среды выполнения.

Изменение в конструкторе рабочих процессов

1. In the trigger's upper-right corner, select the ellipses (...) button, and then select Settings.

2. Under Concurrency Control, set Limit to On.

3. Перетащите ползунок Степень параллелизма к необходимому значению. To run your logic app sequentially, drag the slider value to 1.

Изменение параллелизма цикла Foreach

По умолчанию итерации цикла "For each" запускаются одновременно или параллельно. Это означает, что каждая итерация начнет выполняться до завершения предыдущей итерации. However, the number of concurrently running iterations has a default limit. Если количество параллельно выполняющихся итераций достигает этого предела, все остальные итерации должны ожидать выполнения.

Чтобы изменить ограничение по умолчанию, можно использовать редактор представления кода или конструктор рабочих процессов, так как изменение параметра параллелизма с помощью конструктора добавляет или обновляет runtimeConfiguration.concurrency.repetitions свойство в базовом определении действия "для каждого" и наоборот. Это свойство определяет максимальное число итераций, которые могут выполняться параллельно.

Изменение в представлении кода

В базовом определении "For Each" добавьте или обновите свойство runtimeConfiguration.concurrency.repetitions, которое может иметь значение в диапазоне от 1 до 50.

Ниже приведен пример, который ограничивает параллельные выполнения до 10 итераций.

"For_each" {
   "type": "Foreach",
   "actions": { "<actions-to-run>" },
   "foreach": "<for-each-expression>",
   "runAfter": {},
   "runtimeConfiguration": {
      "concurrency": {
         "repetitions": 10
      }
   }
}

Дополнительные сведения см. в разделе Настройки конфигурации среды выполнения.

Изменение в конструкторе рабочих процессов

1. In the For each action, from the upper-right corner, select the ellipses (...) button, and then select Settings.

2. Under Concurrency Control, set Concurrency Control to On.

3. Перетащите ползунок Степень параллелизма к необходимому значению. To run your logic app sequentially, drag the slider value to 1.

Изменение предела ожидающих запусков

По умолчанию экземпляры рабочего процесса запускаются одновременно или параллельно. Это означает, что каждый экземпляр триггера срабатывает до завершения выполнения предыдущего экземпляра рабочего процесса. However, a default limit exists on the number of concurrently running workflow instances. Когда число одновременных запусков достигает этого ограничения, все другие новые экземпляры рабочих процессов должны ждать выполнения. A default limit also exists on the number of waiting workflow instances. Когда число ожидающих экземпляров достигает этого ограничения, Azure Logic Apps больше не принимает новые экземпляры рабочих процессов для запуска. Триггеры запроса и веб-перехватчика возвращают 429 — слишком много ошибок запросов, а повторяющиеся триггеры начинают пропускать попытки опроса.

Можно изменить ограничение по умолчанию на параллелизм триггера, а также ограничение по умолчанию при ожидании выполнения. Однако это изменение в основном замедляет триггер, чтобы облегчить давление из-за параллелизма. Например, если у вас есть триггер опроса, а очередь ожидающих запусков заполнена из-за выполняемых запусков, Azure Logic Apps останавливает опрос. Если рабочий процесс использует триггер на основе запросов, а очередь ожидания выполняется полностью, Azure Logic Apps начинает возвращать ошибку 429. Некоторые сценарии существуют, когда Azure Logic Apps не может остановить триггер от опроса, не вводя сбои и выбирая добавление таких запусков в очередь ожидающих запусков в любом случае без сбоя вызовов.

В базовом определении триггера добавьте свойство runtimeConfiguration.concurrency.maximumWaitingRuns, которое может иметь значение в диапазоне от 1 до 100.

"<trigger-name>": {
   "type": "<trigger-name>",
   "recurrence": {
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>,
   },
   "runtimeConfiguration": {
      "concurrency": {
         "maximumWaitingRuns": 50
      }
   }
}

Дополнительные сведения см. в разделе Настройки конфигурации среды выполнения.

Последовательная активация экземпляров

Чтобы запустить каждый экземпляр приложения логики только после завершения предыдущего экземпляра, установите триггер в значение последовательного запуска. Вы можете использовать редактор представления кода или конструктор рабочих процессов, так как изменение параметра параллелизма с помощью конструктора также добавляет или обновляет runtimeConfiguration.concurrency.runs свойство в определении базового триггера и наоборот.

Изменение в представлении кода

В определении триггера задайте одно из этих свойств, но не оба.

Задайте для свойства runtimeConfiguration.concurrency.runs значение 1.

"<trigger-name>": {
   "type": "<trigger-name>",
   "recurrence": {
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>,
   },
   "runtimeConfiguration": {
      "concurrency": {
         "runs": 1
      }
   }
}

-or-

Задайте для свойства operationOptions значение SingleInstance.

"<trigger-name>": {
   "type": "<trigger-name>",
   "recurrence": {
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>,
   },
   "operationOptions": "SingleInstance"
}

Дополнительные сведения см. в разделах Настройки конфигурации среды выполнения и Настройки операций.

Изменение в конструкторе рабочих процессов

1. In the trigger's upper-right corner, select the ellipses (...) button, and then select Settings.

2. Under Concurrency Control, set Limit to On.

3. Перетащите ползунок Степень параллелизма на номер 1.

Последовательный запуск циклов Foreach

Чтобы запустить итерацию цикла Foreach только после завершения предыдущей итерации, настройте последовательное выполнение каждого действия. Вы можете использовать редактор представления кода или конструктор рабочих процессов, так как изменение параллелизма действия с помощью конструктора также добавляет или обновляет runtimeConfiguration.concurrency.repetitions свойство в определении базового действия и наоборот.

Изменение в представлении кода

В определении действия задайте один из этих свойств, но не оба.

Задайте для свойства runtimeConfiguration.concurrency.repetitions значение 1.

"For_each" {
   "type": "Foreach",
   "actions": { "<actions-to-run>" },
   "foreach": "<for-each-expression>",
   "runAfter": {},
   "runtimeConfiguration": {
      "concurrency": {
         "repetitions": 1
      }
   }
}

-or-

Задайте для свойства operationOptions значение Sequential.

"For_each" {
   "type": "Foreach",
   "actions": { "<actions-to-run>" },
   "foreach": "<for-each-expression>",
   "runAfter": {},
   "operationOptions": "Sequential"
}

Дополнительные сведения см. в разделах Настройки конфигурации среды выполнения и Настройки операций.

Изменение в конструкторе рабочих процессов

1. In the For each action's upper-right corner, select the ellipses (...) button, and then select Settings.

2. Under Concurrency Control, set Concurrency Control to On.

3. Перетащите ползунок Степень параллелизма на номер 1.

Выполнение действий в шаблоне синхронной операции

По умолчанию действия HTTP Action и APIConnection в Azure Logic Apps соответствуют стандартному шаблону асинхронных операций, а действие "Ответ" (Response) соответствует шаблону синхронных операций. The asynchronous pattern specifies that after an action calls or sends a request to the specified endpoint, service, system, or API, the receiver immediately returns a "202 ACCEPTED" response. Этот код подтверждает, что получатель принял запрос, но еще не завершил обработку. The response can include a location header that specifies the URL and a refresh ID that the caller can use to continually poll or check the status for the asynchronous request until the receiver stops processing and returns a "200 OK" success response or other non-202 response. Дополнительные сведения см. в разделе Асинхронная интеграция микрослужб обеспечивает автономность микрослужб.

• In the Logic App Designer, the HTTP action, APIConnection actions, and Response action have the Asynchronous Pattern setting. Этот параметр указывает, что вызывающая сторона не ждет завершения обработки и может перейти к следующему действию, но продолжит проверку состояния, пока обработка не будет остановлена. При отключенном параметре вызывающая сторона будет ожидать завершения обработки перед переходом к следующему действию. Чтобы найти этот параметр, выполните следующие шаги.

  1. On the HTTP action's title bar, select the ellipses (...) button, which opens the action's settings.

  2. Find the Asynchronous Pattern setting.

     

• В определении базовой нотации объекта JavaScript (JSON) действия HTTP действия и APIConnection косвенным образом соответствуют модели асинхронной операции.

В некоторых случаях может потребоваться, чтобы действие следовало синхронной модели. Например, при использовании действия HTTP может потребоваться:

• Избежать истечения времени ожидания HTTP для долго выполняющихся задач
• Отключить проверку заголовков расположения

В этих случаях можно запустить синхронное выполнение действий с помощью следующих параметров:

• Замените версию опроса действия на версию с веб-перехватчиком, если она доступна.

• Отключите асинхронное поведение действия, выполнив любой из следующих вариантов:

  • В конструкторе приложений логики отключите параметр Асинхронная модель.

  • В базовом определении JSON действия добавьте "DisableAsyncPattern" параметр operation.

Turn off Asynchronous Pattern setting

1. In the Logic App Designer, on the action's title bar, select the ellipses (...) button, which opens the action's settings.

2. Find the Asynchronous Pattern setting, turn the setting to Off if enabled, and select Done.

   

Отключение асинхронной модели в определении JSON для действия

In the action's underlying JSON definition, add and set the "operationOptions" property to "DisableAsyncPattern" under the action's "inputs" section, for example:

"<some-long-running-action>": {
   "type": "Http",
   "inputs": { "<action-inputs>" },
   "operationOptions": "DisableAsyncPattern",
   "runAfter": {}
}

Проверка подлинности триггеров и действий

Конечные точки HTTP и HTTPS поддерживают различные виды проверки подлинности. В зависимости от триггера или действия, используемого для выполнения исходящих вызовов или запросов, обращающихся к этим конечным точкам, у вас есть выбор из диапазона различных типов проверки подлинности. Дополнительные сведения см. в разделе Добавление проверки подлинности в исходящие вызовы далее в этой статье.

Next steps

• См. дополнительные сведения о языке определения рабочего процесса