Schemareferentiegids voor trigger- en actietypen in Azure Logic Apps

In deze verwijzing worden de algemene typen beschreven die worden gebruikt voor het identificeren van triggers en acties in de onderliggende werkstroomdefinitie van uw logische app, die wordt beschreven en gevalideerd door de taal van de werkstroomdefinitie. To find specific connector triggers and actions that you can use in your logic apps, see the list under the Connectors overview.

Triggers overview

Elke werkstroom bevat een trigger, waarmee de aanroepen worden gedefinieerd die de werkstroom instantiëren en starten. Dit zijn de algemene triggercategorieën:

• 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. De trigger wacht vervolgens op het antwoord van het eindpunt voordat deze wordt geactiveerd.

Triggers hebben deze elementen op het hoogste niveau, hoewel sommige optioneel zijn:

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

Lijst met triggertypen

Elk triggertype heeft een andere interface en invoer die het gedrag van de trigger definieert.

Built-in triggers

Beheerde API-triggers

Triggers - gedetailleerde naslaginformatie

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. Veel secties in deze triggerdefinitie zijn optioneel. Het gedrag van de trigger is afhankelijk van of secties wel of niet zijn opgenomen.

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

Met deze triggerdefinitie wordt elke dag gecontroleerd op e-mail in het Postvak IN voor een werk- of schoolaccount:

"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

Deze triggerdefinitie abonneert zich op de Office 365 Outlook-API, biedt een callback-URL naar het API-eindpunt en wacht tot het eindpunt reageert wanneer er een nieuwe e-mail binnenkomt.

"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

Met deze trigger wordt een aanvraag verzonden naar het opgegeven HTTP- of HTTPS-eindpunt op basis van het opgegeven terugkeerschema. De trigger controleert vervolgens het antwoord om te bepalen of de werkstroom wordt uitgevoerd. Zie Service-eindpunten aanroepen via HTTP of HTTPS vanuit Azure Logic Apps voor meer informatie.

"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

Vereisten voor binnenkomende aanvragen

Om goed te kunnen werken met uw logische app, moet het eindpunt voldoen aan een specifiek triggerpatroon of -contract en deze antwoordeigenschappen herkennen:

Voorbeeldgedrag voor verschillende aanvragen

HTTPWebhook trigger

Met deze trigger kan uw logische app worden aangeroepen door een eindpunt te maken dat een abonnement kan registreren door de opgegeven eindpunt-URL aan te roepen. Wanneer u deze trigger in uw werkstroom maakt, wordt met een uitgaande aanvraag het abonnement geregistreerd. Op die manier kan de trigger beginnen met luisteren naar gebeurtenissen. Wanneer een bewerking deze trigger ongeldig maakt, wordt met een uitgaande aanvraag automatisch de aanroep uitgevoerd om het abonnement te annuleren. For more information, see Endpoint subscriptions.

You can also specify asynchronous limits on an HTTPWebhook trigger. Het gedrag van de trigger is afhankelijk van de secties die u gebruikt of weglaat.

"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

Deze trigger maakt een abonnement op het opgegeven eindpunt, biedt een unieke callback-URL en wacht op nieuw gepubliceerde technologieartikelen.

"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

Deze trigger wordt uitgevoerd op basis van het opgegeven terugkeerschema en biedt een eenvoudige manier om een regelmatig actieve werkstroom te maken.

"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

Deze eenvoudige terugkeertrigger wordt dagelijks uitgevoerd:

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

Example 2

U kunt een begindatum en -tijd opgeven voor het activeren van de trigger. Deze terugkeertrigger begint op de opgegeven datum en wordt vervolgens dagelijks geactiveerd:

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

Example 3

Deze terugkeertrigger begint op 9 september 2017 om 2:00 uur en wordt wekelijks elke maandag om 10:30, 12:30 uur en 2:30 uur Pacific Standard Time geactiveerd:

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

Zie Regelmatig actieve taken maken en plannen voor meer informatie plus voorbeelden voor deze trigger.

Request trigger

Met deze trigger kan uw logische app worden aangeroepen door een eindpunt te maken dat binnenkomende aanvragen kan accepteren. Geef voor deze trigger een JSON-schema op waarmee de nettolading of invoer wordt beschreven en gevalideerd die de trigger ontvangt van de binnenkomende aanvraag. Het schema maakt triggereigenschappen ook gemakkelijker te raadplegen vanuit latere acties in de werkstroom.

Als u deze trigger wilt aanroepen, moet u de listCallbackUrl API gebruiken, die wordt beschreven in de REST API van de werkstroomservice. Zie Werkstromen aanroepen, activeren of nesten met HTTP-eindpunten voor meer informatie over het gebruik van deze trigger als een HTTP-eindpunt.

"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

Deze trigger geeft aan dat een binnenkomende aanvraag de HTTP POST-methode moet gebruiken om de trigger aan te roepen en een schema bevat waarmee invoer van de binnenkomende aanvraag wordt gevalideerd:

"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

Voor elke trigger en alleen triggers kunt u een matrix opnemen die een of meer expressies bevat voor voorwaarden die bepalen of de werkstroom moet worden uitgevoerd. Als u de conditions eigenschap wilt toevoegen aan een trigger in uw werkstroom, opent u uw logische app in de codeweergave-editor.

U kunt bijvoorbeeld opgeven dat een trigger alleen wordt geactiveerd wanneer een website een interne serverfout retourneert door te verwijzen naar de statuscode van de trigger in de conditions eigenschap:

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

Standaard wordt een trigger pas geactiveerd nadat een antwoord van 200 OK is ontvangen. Wanneer een expressie verwijst naar de statuscode van een trigger, wordt het standaardgedrag van de trigger vervangen. Dus als u wilt dat de trigger wordt geactiveerd voor meer dan één statuscode, zoals de statuscode '200' en '201', moet u deze expressie opnemen als uw voorwaarde:

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

Meerdere uitvoeringen activeren op een matrix

Als uw trigger een matrix ontvangt die door uw werkstroom moet worden verwerkt, kan het soms te lang duren voordat elk matrixitem wordt verwerkt. Instead, you can use the SplitOn property in your trigger to debatch the array. Debatching splitst de matrixitems op en start een nieuw werkstroomexemplaren die voor elk matrixitem wordt uitgevoerd. Deze methode is bijvoorbeeld handig als u een eindpunt wilt peilen dat mogelijk meerdere nieuwe items retourneert tussen polling-intervallen.

If your trigger's Swagger file describes a payload that's an array, the SplitOn property is automatically added to your trigger. Voeg anders deze eigenschap toe in de nettolading van het antwoord met de matrix die u wilt bespreken.

Bekijk de volgende overwegingen voordat u de SplitOn-functie gebruikt:

• If trigger concurrency is enabled, the SplitOn limit is significantly reduced. Als het aantal items deze limiet overschrijdt, wordt de functie SplitOn uitgeschakeld.

• U kunt de SplitOn-functie niet gebruiken met een synchroon antwoordpatroon. 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

Stel dat u een HTTP-trigger hebt die een API aanroept en dit antwoord ontvangt:

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

Uw werkstroom heeft alleen de inhoud van de matrix nodig, Rowszodat u een trigger zoals in dit voorbeeld kunt maken:

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

Uw werkstroomdefinitie kan nu worden gebruikt @triggerBody().name om de name waarden op te halen, die afkomstig zijn "customer-name-one" van de eerste uitvoering en "customer-name-two" van de tweede uitvoering. Uw triggeruitvoer ziet er dus als volgt uit:

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

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

Actions overview

Azure Logic Apps biedt verschillende actietypen, elk met verschillende invoerwaarden die het unieke gedrag van een actie definiëren. Acties hebben deze elementen op hoog niveau, hoewel sommige optioneel zijn:

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

Lijst met actietypen

Hier volgen enkele veelgebruikte actietypen:

• Ingebouwde actietypen , zoals deze voorbeelden en meer:

  • HTTP for calling endpoints over HTTP or HTTPS

  • Response for responding to requests

  • JavaScript-code uitvoeren voor het uitvoeren van JavaScript-codefragmenten

  • 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

• Beheerde API-actietypen zoals ApiConnection en ApiConnectionWebHook die verschillende connectors en API's aanroepen die worden beheerd door Microsoft, bijvoorbeeld Azure Service Bus, Office 365 Outlook, Power BI, Azure Blob Storage, OneDrive, GitHub en meer

• Werkstroomactietypen beheren, zoals If, Foreach, Switch, Scope en Until, die andere acties bevatten en u helpen bij het organiseren van werkstroomuitvoering

Built-in actions

Beheerde API-acties

Werkstroomacties beheren

Met deze acties kunt u de uitvoering van werkstromen beheren en andere acties opnemen. Van buiten een werkstroomactie voor besturingselementen kunt u rechtstreeks verwijzen naar acties binnen die werkstroomactie voor besturingselementen. Als u bijvoorbeeld een Http actie binnen een bereik hebt, kunt u overal in de werkstroom verwijzen naar de @body('Http') expressie. Acties die zich in een werkstroomactie voor besturingselementen bevinden, kunnen echter alleen worden uitgevoerd na andere acties die zich in dezelfde werkstroomstructuur bevinden.

Acties - Gedetailleerde naslaginformatie

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

In deze definitie wordt de actie Een e-mail verzenden voor Office 365 Outlook-connector beschreven. Dit is een door Microsoft beheerde 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

Met deze actie maakt u één uitvoer van meerdere invoergegevens, inclusief expressies. Zowel de uitvoer als de invoer kunnen elk type hebben dat azure Logic Apps systeemeigen ondersteunt, zoals matrices, JSON-objecten, XML en binair. Vervolgens kunt u de uitvoer van de actie in andere acties gebruiken.

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

Required

Example 1

Deze actiedefinitie wordt abcdefg samengevoegd met een volgruimte en de waarde 1234:

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

Dit is de uitvoer die met deze actie wordt gemaakt:

abcdefg 1234

Example 2

Met deze actiedefinitie wordt een tekenreeksvariabele samengevoegd die een geheel getalvariabele bevat abcdefg1234met:

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

Dit is de uitvoer die met deze actie wordt gemaakt:

"abcdefg1234"

JavaScript-codeactie uitvoeren

Met deze actie wordt een JavaScript-codefragment uitgevoerd en worden de resultaten geretourneerd via een token waarnaar volgende acties in de werkstroom kunnen verwijzen.

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

Required

Vereist in sommige gevallen

Het explicitDependencies kenmerk geeft aan dat u expliciet resultaten van de trigger, eerdere acties of beide als afhankelijkheden voor uw codefragment wilt opnemen. Zie Afhankelijkheden als parameters toevoegen aan een inlinecodeactie voor meer informatie over het toevoegen van deze afhankelijkheden.

Voor het includeTrigger kenmerk kunt u waarden opgeven of true waarden opgevenfalse.

Example 1

Met deze actie wordt code uitgevoerd die de naam van de werkstroom van uw logische app ophaalt en de tekst 'Hallo wereld van <logic-app-name>' retourneert als resultaat. In dit voorbeeld verwijst de code naar de naam van de werkstroom door toegang te krijgen tot de workflowContext.workflow.name eigenschap via het object alleen-lezen workflowContext . Zie Referentietrigger en actieresultaten in uw code voor meer informatie over het gebruik van het workflowContext object.

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

Example 2

Met deze actie wordt code uitgevoerd in een werkstroom van een logische app die wordt geactiveerd wanneer een nieuwe e-mail binnenkomt in een Outlook-account. De werkstroom maakt ook gebruik van de e-mailactie Goedkeuring verzenden in Office 365 Outlook waarmee de inhoud van de ontvangen e-mail wordt doorgestuurd, samen met een verzoek om goedkeuring.

De code extraheert de e-mailadressen uit de eigenschap van Body het e-mailbericht en retourneert de adressen samen met de SelectedOption eigenschapswaarde van de goedkeuringsactie. De actie bevat expliciet de actie Goedkeurings-e-mail verzenden als een afhankelijkheid in het actions object binnen het explicitDependencies object.

"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

Wanneer u uw logische app opslaat, voert Azure Logic Apps deze controles uit op de functie waarnaar wordt verwezen:

• Uw werkstroom moet toegang hebben tot de functie.

• Uw werkstroom kan alleen een standaard HTTP-trigger of algemene JSON-webhooktrigger gebruiken.

  Azure Logic Apps haalt de URL van de trigger op en slaat deze in de cache op, die tijdens runtime wordt gebruikt. However, if any operation invalidates the cached URL, the Function action fails at runtime. U kunt dit probleem oplossen door de logische app opnieuw op te slaan, zodat de logische app de trigger-URL opnieuw in de cache opslaat.

• De functie kan geen route hebben gedefinieerd.

• Alleen de autorisatieniveaus 'functie' en 'anoniem' zijn toegestaan.

Example

Met deze actiedefinitie wordt de eerder gemaakte functie GetProductID aangeroepen:

"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

Met deze actie wordt een aanvraag verzonden naar het opgegeven HTTP- of HTTPS-eindpunt en wordt het antwoord gecontroleerd om te bepalen of de werkstroom wordt uitgevoerd. Zie Service-eindpunten aanroepen via HTTP of HTTPS vanuit Azure Logic Apps voor meer informatie.

"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

Deze actiedefinitie haalt het laatste nieuws op door een aanvraag naar het opgegeven eindpunt te verzenden:

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

Join action

Met deze actie maakt u een tekenreeks van alle items in een matrix en scheidt u deze items met het opgegeven scheidingsteken.

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

Required

Example

Stel dat u een eerder gemaakte variabele 'myIntegerArray' hebt die deze matrix met gehele getallen bevat:

[1,2,3,4]

Deze actiedefinitie haalt de waarden van de variabele op met behulp van de variables() functie in een expressie en maakt deze tekenreeks met deze waarden, gescheiden door een komma: "1,2,3,4"

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

JSON-actie parseren

This action creates user-friendly fields or tokens from the properties in JSON content. U kunt deze eigenschappen vervolgens openen in uw logische app met behulp van de tokens. Als u bijvoorbeeld JSON-uitvoer van services zoals Azure Service Bus en Azure Cosmos DB wilt gebruiken, kunt u deze actie opnemen in uw logische app, zodat u gemakkelijker naar de gegevens in die uitvoer kunt verwijzen.

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

In dit voorbeeld geeft de eigenschap 'inhoud' de JSON-inhoud op voor de actie die moet worden geparseerd. U kunt deze JSON-inhoud ook opgeven als de voorbeeldpayload voor het genereren van het schema.

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

De eigenschap Schema geeft het JSON-schema op dat wordt gebruikt voor het beschrijven van de JSON-inhoud:

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

Query action

Met deze actie maakt u een matrix op basis van items in een andere matrix op basis van een opgegeven voorwaarde of filter.

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

Required

Example

Met deze actiedefinitie maakt u een matrix met waarden die groter zijn dan de opgegeven waarde. Dit zijn twee:

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

Response action

Met deze actie maakt u de nettolading voor het antwoord op een HTTP-aanvraag.

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

Required

Optional

Example

Met deze actiedefinitie wordt een antwoord gemaakt op een HTTP-aanvraag met de opgegeven statuscode, berichttekst en berichtkoppen:

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

  Als uw werkstroom echter een andere logische app aanroept als een geneste werkstroom, wacht de bovenliggende werkstroom totdat de geneste werkstroom is voltooid, ongeacht hoe lang de geneste werkstroom is voltooid.

• 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. Controleer op dit geval wanneer de PUT-methode wordt gebruikt en indien waar, een 'ongeldige aanvraag' retourneert.

  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. Als gevolg hiervan wordt de uitvoering van uw logische app ook gemarkeerd met de status Mislukt.

Select action

Met deze actie maakt u een matrix met JSON-objecten door items van een andere matrix te transformeren op basis van de opgegeven kaart. De uitvoermatrix en de bronmatrix hebben altijd hetzelfde aantal items. Hoewel u het aantal objecten in de uitvoermatrix niet kunt wijzigen, kunt u eigenschappen en de bijbehorende waarden aan deze objecten toevoegen of verwijderen. De select eigenschap geeft ten minste één sleutel-waardepaar op waarmee de kaart wordt gedefinieerd voor het transformeren van items in de bronmatrix. Een sleutel-waardepaar vertegenwoordigt een eigenschap en de bijbehorende waarde voor alle objecten in de uitvoermatrix.

"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

Met deze actiedefinitie maakt u een JSON-objectmatrix op basis van een gehele getalmatrix. De actie doorloopt de bronmatrix, haalt elke gehele waarde op met behulp van de @item() expressie en wijst elke waarde toe aan de eigenschap 'number' in elk JSON-object:

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

Dit is de matrix die met deze actie wordt gemaakt:

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

Met deze actie maakt u een CSV- of HTML-tabel op basis van een matrix. Voor matrices met JSON-objecten maakt deze actie automatisch de kolomkoppen op basis van de eigenschapsnamen van de objecten. Voor matrices met andere gegevenstypen moet u de kolomkoppen en -waarden opgeven. Deze matrix bevat bijvoorbeeld de eigenschappen 'ID' en 'Product_Name' die deze actie kan gebruiken voor de kolomkopnamen:

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

Als u kolomkoppen en -waarden wilt opgeven of aanpassen, gebruikt u de columns matrix. Wanneer header-value paren dezelfde kopnaam hebben, worden hun waarden weergegeven in dezelfde kolom onder die kopnaam. Anders definieert elke unieke kop een unieke kolom.

Example 1

Stel dat u een eerder gemaakte variabele 'myItemArray' hebt die momenteel deze matrix bevat:

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

Met deze actiedefinitie wordt een CSV-tabel gemaakt op basis van de variabele myItemArray. Met de expressie die door de from eigenschap wordt gebruikt, wordt de matrix opgehaald uit 'myItemArray' met behulp van de variables() functie:

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

Dit is de CSV-tabel die met deze actie wordt gemaakt:

ID,Product_Name 
0,Apples 
1,Oranges 

Example 2

Met deze actiedefinitie wordt een HTML-tabel gemaakt op basis van de variabele myItemArray. Met de expressie die door de from eigenschap wordt gebruikt, wordt de matrix opgehaald uit 'myItemArray' met behulp van de variables() functie:

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

Hier volgt de HTML-tabel die met deze actie wordt gemaakt:

Example 3

Met deze actiedefinitie wordt een HTML-tabel gemaakt op basis van de variabele myItemArray. In dit voorbeeld worden de standaardnamen van kolomkoppen echter overschreven met 'Stock_ID' en 'Beschrijving', en wordt het woord 'Organisch' toegevoegd aan de waarden in de kolom Beschrijving.

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

Hier volgt de HTML-tabel die met deze actie wordt gemaakt:

Terminate action

Deze actie stopt de uitvoering voor een werkstroomexemplaren, annuleert alle acties die worden uitgevoerd, slaat alle resterende acties over en retourneert de opgegeven status. 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

De eigenschappen voor het object runError zijn alleen van toepassing wanneer de eigenschap 'runStatus' is ingesteld op De status Mislukt.

Example

Deze actiedefinitie stopt een werkstroomuitvoering, stelt de uitvoeringsstatus in op Mislukt en retourneert de status, een foutcode en een foutbericht:

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

Wait action

Met deze actie wordt de uitvoering van de werkstroom onderbroken voor het opgegeven interval of tot de opgegeven tijd, maar niet beide.

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

Met deze actiedefinitie wordt de werkstroom gedurende 15 minuten onderbroken:

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

Example 2

Met deze actiedefinitie wordt de werkstroom onderbroken tot de opgegeven tijd:

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

Workflow action

Met deze actie wordt een andere eerder gemaakte logische app aangeroepen, wat betekent dat u andere werkstromen voor logische apps kunt opnemen en opnieuw kunt gebruiken. 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 controleert de toegang tot de trigger die u wilt aanroepen, dus zorg ervoor dat u toegang hebt tot die trigger. De geneste logische app moet ook voldoen aan deze criteria:

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

• Hetzelfde Azure-abonnement als uw bovenliggende logische app

• 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

De uitvoer van deze actie varieert op basis van de reactieactie van de geneste logische app. Als de geneste logische app geen antwoordactie bevat, zijn de uitvoer leeg.

Example

Nadat de actie 'Start_search' is voltooid, roept deze werkstroomactiedefinitie een andere logische app aan met de naam 'Get_product_information', die de opgegeven invoer doorgeeft:

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

Details van werkstroomactie beheren

Foreach action

Deze lusactie doorloopt een matrix en voert acties uit op elk matrixitem. Standaard wordt de lus 'voor elke' parallel uitgevoerd tot een maximum aantal lussen. Zie Limieten en configuratie voor dit maximum. Meer informatie over het maken van 'voor elke' lussen.

"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

Deze lus 'voor elke' verzendt een e-mail voor elk item in de matrix, dat bijlagen van een binnenkomende e-mail bevat. De lus verzendt een e-mailbericht, inclusief de bijlage, naar een persoon die de bijlage beoordeelt.

"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. Om een fout te voorkomen als de matrix niet bestaat, gebruikt de expressie de ? operator:

@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. Als de voorwaarde waar is, wordt de voorwaarde gemarkeerd met de status Geslaagd. Meer informatie over het maken van voorwaardelijke instructies.

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

De acties in de actions of else objecten krijgen deze statussen:

• 'Geslaagd' wanneer ze worden uitgevoerd en geslaagd
• 'Mislukt' wanneer ze worden uitgevoerd en mislukken
• 'Overgeslagen' wanneer de respectieve vertakking niet wordt uitgevoerd

Example

Deze voorwaarde geeft aan dat wanneer de variabele geheel getal een waarde heeft die groter is dan nul, de werkstroom een website controleert. Als de variabele nul of minder is, controleert de werkstroom een andere website.

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

Hoe voorwaarden expressies gebruiken

Hier volgen enkele voorbeelden die laten zien hoe u expressies in voorwaarden kunt gebruiken:

Scope action

This action logically groups actions into scopes, which get their own status after the actions in that scope finish running. Vervolgens kunt u de status van het bereik gebruiken om te bepalen of andere acties worden uitgevoerd. Meer informatie over het maken van bereiken.

"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. Meer informatie over het maken van switchinstructies.

"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

Met deze actiedefinitie wordt geëvalueerd of de persoon die op de e-mail van de goedkeuringsaanvraag reageert, de optie Goedkeuren of De optie Weigeren heeft geselecteerd. 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

Deze lusactie bevat acties die worden uitgevoerd totdat de opgegeven voorwaarde waar is. De lus controleert de voorwaarde als laatste stap nadat alle andere acties zijn uitgevoerd. U kunt meer dan één actie opnemen in het "actions" object en de actie moet ten minste één limiet definiëren. Meer informatie over het maken van 'until'-lussen.

 "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

Deze lusactiedefinitie verzendt een HTTP-aanvraag naar de opgegeven URL totdat aan een van deze voorwaarden wordt voldaan:

• De aanvraag ontvangt een antwoord met de statuscode 200 OK.
• De lus is 60 keer uitgevoerd.
• De lus is één uur uitgevoerd.

 "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 en abonnementen

Triggers en acties op basis van webhook controleren niet regelmatig eindpunten, maar wachten op specifieke gebeurtenissen of gegevens op die eindpunten. These triggers and actions subscribe to the endpoints by providing a callback URL where the endpoint can send responses.

De subscribe aanroep vindt plaats wanneer de werkstroom op welke manier dan ook verandert, bijvoorbeeld wanneer referenties worden vernieuwd of wanneer de invoerparameters voor een trigger of actie worden gewijzigd. Deze aanroep maakt gebruik van dezelfde parameters als standaard HTTP-acties.

De unsubscribe aanroep wordt automatisch uitgevoerd wanneer een bewerking de trigger of actie ongeldig maakt, bijvoorbeeld:

• De trigger verwijderen of uitschakelen.
• De werkstroom verwijderen of uitschakelen.
• Het abonnement verwijderen of uitschakelen.

Ter ondersteuning van deze aanroepen retourneert de @listCallbackUrl() expressie een unieke callback-URL voor de trigger of actie. Deze URL vertegenwoordigt een unieke id voor de eindpunten die gebruikmaken van de REST API van de service. De parameters voor deze functie zijn hetzelfde als de webhooktrigger of -actie.

Asynchrone duur wijzigen

Voor zowel triggers als acties kunt u de duur voor het asynchrone patroon beperken tot een specifiek tijdsinterval door de limit.timeout eigenschap toe te voegen. Als de actie niet is voltooid wanneer het interval is verstreken, wordt de status van de actie gemarkeerd als Cancelled met de ActionTimedOut code. De timeout eigenschap maakt gebruik van de ISO 8601-indeling.

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

Runtime-configuratie-instellingen

U kunt het standaardruntimegedrag voor triggers en acties wijzigen door deze runtimeConfiguration eigenschappen toe te voegen aan de trigger- of actiedefinitie.

Operation options

U kunt het standaardgedrag voor triggers en acties wijzigen met de operationOptions eigenschap in de trigger- of actiedefinitie.

Gelijktijdigheid van triggers wijzigen

Werkstroomexemplaren van logische apps worden standaard allemaal tegelijk uitgevoerd (gelijktijdig of parallel). Dit gedrag betekent dat elke triggerinstantie wordt geactiveerd voordat het eerder actieve werkstroomexemplaren zijn uitgevoerd. However, the number of concurrently running instances has a default limit. Wanneer het aantal gelijktijdig actieve werkstroomexemplaren deze limiet bereikt, moeten andere nieuwe exemplaren wachten totdat deze wordt uitgevoerd. Deze limiet helpt bij het beheren van het aantal aanvragen dat back-endsystemen ontvangen.

When you turn on the trigger's concurrency control, trigger instances run in parallel up to the default limit. Als u deze standaardlimiet voor gelijktijdigheid wilt wijzigen, kunt u de codeweergave-editor of de werkstroomontwerper gebruiken, omdat het wijzigen van de gelijktijdigheidsinstelling via de ontwerpfunctie de runtimeConfiguration.concurrency.runs eigenschap toevoegt of bijwerkt in de onderliggende triggerdefinitie en omgekeerd. Met deze eigenschap bepaalt u het maximum aantal nieuwe werkstroomexemplaren dat parallel kan worden uitgevoerd.

Bekijk de volgende overwegingen voordat u gelijktijdigheid inschakelt voor een trigger:

• U kunt gelijktijdigheid niet uitschakelen nadat u het gelijktijdigheidsbeheer hebt ingeschakeld.

• Als het maximum aantal gelijktijdige triggeruitvoeringen de maximale mate van parallelle uitvoering bereikt, kunnen volgende triggeruitvoeringen leiden tot beperking of fouten met '429 - Te veel aanvragen'. Als u een beleid voor opnieuw proberen instelt dat 429-fouten afhandelt, kan de trigger een cyclus van opnieuw proberen en beperkingsgedrag ervaren dat lange vertragingen veroorzaakt bij het verwerken van nieuwe triggeraanvragen.

• When concurrency is enabled, the SplitOn limit is significantly reduced for debatching arrays. Als het aantal items deze limiet overschrijdt, wordt de functie SplitOn uitgeschakeld.

• Wanneer gelijktijdigheid is ingeschakeld, kan een langlopend exemplaar van een logische app ervoor zorgen dat nieuwe exemplaren van logische apps een wachtstatus invoeren. Deze status voorkomt dat Azure Logic Apps nieuwe exemplaren maakt en zelfs gebeurt wanneer het aantal gelijktijdige uitvoeringen kleiner is dan het opgegeven maximum aantal gelijktijdige uitvoeringen.

  • 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. Selecteer onder Uitvoering van logische app de optie Uitvoering annuleren.

       

  • Als u deze mogelijkheid wilt omzeilen, voegt u een time-out toe aan een actie die deze uitvoeringen kan bevatten. Als u in de code-editor werkt, raadpleegt u Asynchrone duur wijzigen. Als u de ontwerpfunctie gebruikt, voert u anders de volgende stappen uit:

    1. Selecteer in de werkstroom van uw logische app de actie waaraan u een time-out wilt toevoegen. 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.

       

• Als u uw logische app opeenvolgend wilt uitvoeren, stelt u de gelijktijdigheid 1 van de trigger in op ofwel met behulp van de codeweergave-editor of de ontwerper. Zorg ervoor dat u de eigenschap operationOptions van SingleInstance de trigger niet ook instelt in de codeweergave-editor. Anders krijgt u een validatiefout. Zie Trigger-exemplaren opeenvolgend voor meer informatie.

Bewerken in de codeweergave

Voeg in de onderliggende triggerdefinitie de runtimeConfiguration.concurrency.runs eigenschap toe en stel de waarde in op basis van de gelijktijdigheidslimieten van de trigger. Als u uw werkstroom opeenvolgend wilt uitvoeren, stelt u de eigenschapswaarde in op 1.

In dit voorbeeld worden gelijktijdige uitvoeringen beperkt tot 10 exemplaren:

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

Zie Runtime-configuratie-instellingen voor meer informatie.

Bewerken in de werkstroomontwerper

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. Sleep de schuifregelaar Degree of Parallelism naar de gewenste waarde. To run your logic app sequentially, drag the slider value to 1.

Gelijktijdigheid 'voor elke' wijzigen

Standaard worden herhalingen voor elke lus op hetzelfde moment uitgevoerd (gelijktijdig of parallel). Dit gedrag betekent dat elke iteratie wordt uitgevoerd voordat de vorige iteratie is uitgevoerd. However, the number of concurrently running iterations has a default limit. Wanneer het aantal gelijktijdig uitgevoerde iteraties deze limiet bereikt, moeten alle andere iteraties wachten om te worden uitgevoerd.

Als u de standaardlimiet wilt wijzigen, kunt u de codeweergave-editor of de werkstroomontwerper gebruiken, omdat u de gelijktijdigheidsinstelling via de ontwerpfunctie wijzigt of de runtimeConfiguration.concurrency.repetitions eigenschap bijwerkt in de onderliggende actiedefinitie voor elke actie en omgekeerd. Deze eigenschap bepaalt het maximum aantal iteraties dat parallel kan worden uitgevoerd.

Bewerken in de codeweergave

Voeg in de onderliggende definitie voor elke definitie de eigenschap toe of werk deze runtimeConfiguration.concurrency.repetitions bij, die een waarde kan hebben die varieert van 1 en 50.

Hier volgt een voorbeeld waarmee gelijktijdige uitvoeringen worden beperkt tot 10 iteraties:

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

Zie Runtime-configuratie-instellingen voor meer informatie.

Bewerken in de werkstroomontwerper

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. Sleep de schuifregelaar Degree of Parallelism naar de gewenste waarde. To run your logic app sequentially, drag the slider value to 1.

Limiet voor wachtende uitvoeringen wijzigen

Werkstroomexemplaren van logische apps worden standaard allemaal tegelijk uitgevoerd (gelijktijdig of parallel). Dit gedrag betekent dat elke triggerinstantie wordt geactiveerd voordat het eerder actieve werkstroomexemplaren zijn uitgevoerd. However, a default limit exists on the number of concurrently running workflow instances. Wanneer het aantal gelijktijdige uitvoeringen deze limiet bereikt, moeten andere nieuwe werkstroomexemplaren wachten totdat deze wordt uitgevoerd. A default limit also exists on the number of waiting workflow instances. Wanneer het aantal wachtende exemplaren deze limiet bereikt, accepteert Azure Logic Apps geen nieuwe werkstroomexemplaren meer om uit te voeren. Aanvraag- en webhooktriggers retourneren 429 - Te veel aanvragenfouten en terugkerende triggers beginnen met het overslaan van pollingpogingen.

U kunt de standaardlimiet voor gelijktijdigheid van triggers en de standaardlimiet voor wachtende uitvoeringen wijzigen. Deze wijziging vertraagt echter voornamelijk de trigger om de druk te verlichten als gevolg van gelijktijdigheid. Als u bijvoorbeeld een poll-trigger hebt en de wachtrij voor wachtende uitvoeringen vol is vanwege uitvoeringen die worden uitgevoerd, stopt Azure Logic Apps met polling. Als uw werkstroom gebruikmaakt van een trigger op basis van aanvragen en de wachtrij voor wachtende uitvoeringen vol is, retourneert Azure Logic Apps de fout 429. Sommige scenario's bestaan waarbij Azure Logic Apps de trigger niet kan stoppen met pollen zonder fouten te introduceren en ervoor kiest om dergelijke uitvoeringen toch toe te voegen aan de wachtrij voor wachtende uitvoeringen zonder dat de aanroepen mislukken.

Voeg in de onderliggende triggerdefinitie de runtimeConfiguration.concurrency.maximumWaitingRuns eigenschap toe, die een waarde kan hebben die varieert van 1 tot 100.

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

Zie Runtime-configuratie-instellingen voor meer informatie.

Triggerexemplaren sequentieel

Als u elk werkstroomexemplaren van een logische app alleen wilt uitvoeren nadat het vorige exemplaar is uitgevoerd, stelt u de trigger in om sequentieel uit te voeren. U kunt de codeweergave-editor of de werkstroomontwerper gebruiken, omdat u de gelijktijdigheidsinstelling via de ontwerpfunctie ook toevoegt of bijwerkt runtimeConfiguration.concurrency.runs in de onderliggende triggerdefinitie en omgekeerd.

Bewerken in de codeweergave

Stel in de triggerdefinitie een van deze eigenschappen in, maar niet beide.

Stel de runtimeConfiguration.concurrency.runs eigenschap in op 1:

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

-or-

Stel de operationOptions eigenschap in op SingleInstance:

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

Zie Runtime-configuratie-instellingen en bewerkingsopties voor meer informatie.

Bewerken in de werkstroomontwerper

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. Sleep de schuifregelaar Degree of Parallelism naar het getal 1.

Voer sequentieel 'voor elke' lussen uit

Als u een lusiteratie 'voor elke' alleen wilt uitvoeren nadat de vorige iteratie is uitgevoerd, stelt u de actie 'voor elke' in om sequentieel uit te voeren. U kunt de codeweergave-editor of de werkstroomontwerper gebruiken, omdat u de gelijktijdigheid van de actie wijzigt via ontwerper ook de runtimeConfiguration.concurrency.repetitions eigenschap toevoegt of bijwerkt in de onderliggende actiedefinitie en omgekeerd.

Bewerken in de codeweergave

Stel in de actiedefinitie een van deze eigenschappen in, maar niet beide.

Stel de runtimeConfiguration.concurrency.repetitions eigenschap in op 1:

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

-or-

Stel de operationOptions eigenschap in op Sequential:

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

Zie Runtime-configuratie-instellingen en bewerkingsopties voor meer informatie.

Bewerken in de werkstroomontwerper

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. Sleep de schuifregelaar Degree of Parallelism naar het getal 1.

Acties uitvoeren in een synchrone bewerkingspatroon

De HTTP-actie en APIConnection-acties in Azure Logic Apps volgen standaard het standaard asynchrone bewerkingspatroon, terwijl de actie Antwoord het synchrone bewerkingspatroon volgt. 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. Deze code bevestigt dat de ontvanger de aanvraag heeft geaccepteerd, maar nog niet is verwerkt. 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. Zie Asynchrone microservice-integratie dwingt microserviceautonomie af voor meer informatie.

• In the Logic App Designer, the HTTP action, APIConnection actions, and Response action have the Asynchronous Pattern setting. Wanneer deze instelling is ingeschakeld, geeft deze instelling aan dat de beller niet wacht tot de verwerking is voltooid en verder kan gaan met de volgende actie, maar de status blijft controleren totdat de verwerking stopt. Als deze instelling is uitgeschakeld, geeft deze instelling aan dat de beller wacht tot de verwerking is voltooid voordat de volgende actie wordt uitgevoerd. Volg deze stappen om deze instelling te vinden:

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

  2. Find the Asynchronous Pattern setting.

     

• In de onderliggende JSON-definitie (JavaScript Object Notation) van de actie volgen de HTTP-actie en APIConnection-acties impliciet het asynchrone bewerkingspatroon.

In sommige scenario's wilt u mogelijk dat een actie het synchrone patroon volgt. Wanneer u bijvoorbeeld de HTTP-actie gebruikt, kunt u het volgende doen:

• HTTP-time-outs voorkomen voor langlopende taken
• Locatiekoppen controleren uitschakelen

In deze gevallen kunt u een actie synchroon uitvoeren met behulp van deze opties:

• Vervang de polling-versie van die actie door een webhookversie, indien beschikbaar.

• Schakel het asynchrone gedrag van de actie uit door een van de volgende opties te volgen:

  • Schakel in logic app Designer de instelling Asynchroon patroon uit.

  • Voeg in de onderliggende JSON-definitie van de actie de "DisableAsyncPattern" bewerkingsoptie toe.

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.

   

Asynchroon patroon uitschakelen in de JSON-definitie van de actie

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

Triggers en acties verifiëren

HTTP- en HTTPS-eindpunten ondersteunen verschillende soorten verificatie. Op basis van de trigger of actie die u gebruikt om uitgaande aanroepen of aanvragen voor toegang tot deze eindpunten te maken, kunt u kiezen uit verschillende typen verificatie. Zie Verificatie toevoegen aan uitgaande oproepen voor meer informatie.

Next steps

• Meer informatie over werkstroomdefinitietaal