Schemareferensguide för utlösar- och åtgärdstyper i Azure Logic Apps

Artikel
05/20/2024

Den här referensen beskriver de allmänna typer som används för att identifiera utlösare och åtgärder i logikappens underliggande arbetsflödesdefinition, som beskrivs och verifieras av arbetsflödesdefinitionsspråket. Information om hur du hittar specifika anslutningsutlösare och åtgärder som du kan använda i dina logikappar finns i listan under översikten över Anslut orer.

Översikt över utlösare

Varje arbetsflöde innehåller en utlösare som definierar de anrop som instansierar och startar arbetsflödet. Här är de allmänna utlösarkategorierna:

En avsökningsutlösare som kontrollerar en tjänsts slutpunkt med jämna mellanrum
En push-utlösare som skapar en prenumeration på en slutpunkt och tillhandahåller en motringnings-URL så att slutpunkten kan meddela utlösaren när den angivna händelsen inträffar eller data är tillgängliga. Utlösaren väntar sedan på slutpunktens svar innan den utlöses.

Utlösare har dessa element på den översta nivån, även om vissa är valfria:

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

Krävs

Värde	Typ	Beskrivning
<trigger-name>	String	Namnet på utlösaren
<utlösartyp>	String	Utlösartypen, till exempel "Http" eller "Api Anslut ion"
<trigger-inputs>	JSON-objekt	Indata som definierar utlösarens beteende
<tidsenhet>	String	Den tidsenhet som beskriver hur ofta utlösaren utlöses: "Second", "Minute", "Hour", "Day", "Week", "Month"
<antal tidsenheter>	Integer	Ett värde som anger hur ofta utlösaren utlöses baserat på frekvensen, vilket är antalet tidsenheter som ska vänta tills utlösaren utlöses igen Här är de minsta och högsta intervallen: - Månad: 1–16 månader – Dag: 1–500 dagar – Timme: 1–12 000 timmar – Minut: 1–72 000 minuter – Sekund: 1–9 999 999 sekunder Om intervallet till exempel är 6 och frekvensen är "Månad" är upprepningen var 6:e månad.

Valfritt

Värde	Typ	Beskrivning
<array-with-conditions>	Matris	En matris som innehåller ett eller flera villkor som avgör om arbetsflödet ska köras. Endast tillgängligt för utlösare.
<runtime-config-options>	JSON-objekt	Du kan ändra körningsbeteendet för utlösare genom att ange `runtimeConfiguration` egenskaper. Mer information finns i Konfigurationsinställningar för Körning.
<splitOn-expression>	String	För utlösare som returnerar en matris kan du ange ett uttryck som delar upp eller diskar matrisobjekt i flera arbetsflödesinstanser för bearbetning.
<åtgärdsalternativ>	String	Du kan ändra standardbeteendet genom att ange egenskapen `operationOptions` . Mer information finns i Åtgärdsalternativ.

Lista över utlösartyper

Varje utlösartyp har ett annat gränssnitt och indata som definierar utlösarens beteende.

Inbyggda utlösare

Utlösartyp	beskrivning
HTTP	Kontrollerar eller avsöker valfri slutpunkt. Den här slutpunkten måste överensstämma med ett specifikt utlösarkontrakt antingen med hjälp av ett `202` asynkront mönster eller genom att returnera en matris.
HTTPWebhook	Skapar en anropsbar slutpunkt för logikappen men anropar den angivna URL:en för att registrera eller avregistrera.
Upprepning	Utlöses baserat på ett definierat schema. Du kan ange ett framtida datum och tid för att utlösa den här utlösaren. Baserat på frekvensen kan du också ange tider och dagar för att köra arbetsflödet.
Begär	Skapar en anropsbar slutpunkt för logikappen och kallas även för en "manuell" utlösare. Se till exempel Anropa, utlösa eller kapsla arbetsflöden med HTTP-slutpunkter.

Hanterade API-utlösare

Utlösartyp	beskrivning
ApiConnection	Kontrollerar eller avsöker en slutpunkt med hjälp av Microsoft-hanterade API:er eller "anslutningsappar".
Api Anslut ionWebhook	Skapar en anropsbar slutpunkt för logikappens arbetsflöde genom att anropa Microsoft-hanterade API:er eller "anslutningsappar" för att prenumerera och avbryta prenumerationen.

Utlösare – detaljerad referens

API Anslut ionsutlösare

Den här utlösaren kontrollerar eller avsöker en slutpunkt med hjälp av Microsoft-hanterade API:er eller "anslutningsappar" så att parametrarna för den här utlösaren kan variera beroende på slutpunkten. Många avsnitt i den här utlösardefinitionen är valfria. Utlösarens beteende beror på om avsnitt ingår eller inte.

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

Krävs

Property	Värde	Typ	Description
None	<API Anslut ion_trigger_name>	String	Namnet på utlösaren
host.connection.name	<anslutningsnamn>	String	Namnet på anslutningen till det hanterade API som arbetsflödet använder
Metod	<metodtyp>	String	HTTP-metoden för kommunikation med det hanterade API:et: GET, PUT, POST, PATCH, DELETE
sökväg	<api-operation>	String	API-åtgärden som ska anropas
recurrence.frequency	<tidsenhet>	String	Den tidsenhet som beskriver hur ofta utlösaren utlöses: Sekund, Minut, Timme, Dag, Vecka, Månad
recurrence.interval	<antal tidsenheter>	Integer	Ett värde som anger hur ofta utlösaren utlöses baserat på frekvensen, vilket är antalet tidsenheter som ska vänta tills utlösaren utlöses igen Här är de minsta och högsta intervallen: - Månad: 1–16 månader - Dag: 1–500 dagar - Timme: 1-12 000 timmar - Minut: 1-72 000 minuter - Andra: 1-9,999,999 sekunder Om intervallet till exempel är 6 och frekvensen är Månad är upprepningen var 6:e månad.

Valfritt

Property	Värde	Typ	Beskrivning
retryPolicy	<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
Frågor	<query-parameters>	JSON-objekt	Alla frågeparametrar som ska inkluderas med API-anropet. Objektet lägger `?api-version=2018-01-01` till till `"queries": { "api-version": "2018-01-01" }` anropet.
runtimeConfiguration.concurrency.runs	<max-runs>	Integer	Som standard körs arbetsflödesinstanser samtidigt (samtidigt eller parallellt) upp till standardgränsen. Information om hur du ändrar den här gränsen genom att ange ett nytt <antal> värden finns i Ändra utlösarens samtidighet.
runtimeConfiguration.maximumWaitingRuns	<max-runs-queue>	Integer	Om arbetsflödet redan kör det maximala antalet instanser placeras alla nya körningar i den här kön upp till standardgränsen. Information om hur du ändrar standardgränsen finns i Ändra gränsen för väntande körningar. Om du vill ändra det maximala antalet instanser anger du ett värde för egenskapen runtimeConfiguration.concurrency.runs . Obs! Om du ställer in
splitOn	<splitOn-expression>	String	För utlösare som returnerar matriser refererar det här uttrycket till matrisen som ska användas så att du kan skapa och köra en arbetsflödesinstans för varje matrisobjekt i stället för att använda en "för varje"-loop. Det här uttrycket representerar till exempel ett objekt i matrisen som returneras i utlösarens brödtextinnehåll: `@triggerbody()?['value']`
operationOptions	<åtgärdsalternativ>	String	Du kan ändra standardbeteendet genom att ange egenskapen `operationOptions` . Mer information finns i Åtgärdsalternativ.

Utdata

Element	Typ	Beskrivning
Headers	JSON-objekt	Rubrikerna från svaret
brödtext	JSON-objekt	Brödtexten från svaret
statuskod	Integer	Statuskoden från svaret

Exempel

Den här utlösardefinitionen söker efter e-post varje dag i inkorgen efter ett arbets- eller skolkonto:

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

Api Anslut ionWebhook-utlösare

Den här utlösaren skickar en prenumerationsbegäran till en slutpunkt med hjälp av ett Microsoft-hanterat API, tillhandahåller en motringnings-URL där slutpunkten kan skicka ett svar och väntar tills slutpunkten svarar. Mer information finns i Slutpunktsprenumerationer.

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

Krävs

Värde	Typ	Beskrivning
<anslutningsnamn>	String	Namnet på anslutningen till det hanterade API som arbetsflödet använder
<body-content>	JSON-objekt	Meddelandeinnehåll som ska skickas som nyttolast till det hanterade API:et

Valfritt

Värde	Typ	Beskrivning
<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
<query-parameters>	JSON-objekt	Alla frågeparametrar som ska inkluderas med API-anropet Objektet lägger `?api-version=2018-01-01` till till `"queries": { "api-version": "2018-01-01" }` anropet.
<max-runs>	Integer	Som standard körs arbetsflödesinstanser samtidigt (samtidigt eller parallellt) upp till standardgränsen. Information om hur du ändrar den här gränsen genom att ange ett nytt <antal> värden finns i Ändra utlösarens samtidighet.
<max-runs-queue>	Integer	När arbetsflödet redan kör det maximala antalet instanser, som du kan ändra baserat på `runtimeConfiguration.concurrency.runs` egenskapen, placeras alla nya körningar i den här kön upp till standardgränsen. Information om hur du ändrar standardgränsen finns i Ändra gränsen för väntande körningar.
<splitOn-expression>	String	För utlösare som returnerar matriser refererar det här uttrycket till matrisen som ska användas så att du kan skapa och köra en arbetsflödesinstans för varje matrisobjekt i stället för att använda en "för varje"-loop. Det här uttrycket representerar till exempel ett objekt i matrisen som returneras i utlösarens brödtextinnehåll: `@triggerbody()?['value']`
<åtgärdsalternativ>	String	Du kan ändra standardbeteendet genom att ange egenskapen `operationOptions` . Mer information finns i Åtgärdsalternativ.

Exempel

Den här utlösardefinitionen prenumererar på Office 365 Outlook-API:et, tillhandahåller en motringnings-URL till API-slutpunkten och väntar på att slutpunkten ska svara när ett nytt e-postmeddelande kommer.

"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-utlösare

Den här utlösaren skickar en begäran till den angivna HTTP- eller HTTPS-slutpunkten baserat på det angivna upprepningsschemat. Utlösaren kontrollerar sedan svaret för att avgöra om arbetsflödet körs. Mer information finns i Anropa tjänstslutpunkter via HTTP eller HTTPS från 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>"
}

Krävs

Property	Värde	Typ	Beskrivning
`method`	<metodtyp>	String	Den metod som ska användas för att skicka den utgående begäran: "GET", "PUT", "POST", "PATCH" eller "DELETE"
`uri`	<HTTP-or-HTTPS-endpoint-URL>	String	HTTP- eller HTTPS-slutpunkts-URL:en där du vill skicka den utgående begäran. Maximal strängstorlek: 2 KB För en Azure-tjänst eller resurs innehåller den här URI-syntaxen resurs-ID:t och sökvägen till den resurs som du vill komma åt.
`frequency`	<tidsenhet>	String	Den tidsenhet som beskriver hur ofta utlösaren utlöses: "Second", "Minute", "Hour", "Day", "Week", "Month"
`interval`	<antal tidsenheter>	Integer	Ett värde som anger hur ofta utlösaren utlöses baserat på frekvensen, vilket är antalet tidsenheter som ska vänta tills utlösaren utlöses igen Här är de minsta och högsta intervallen: - Månad: 1–16 månader – Dag: 1–500 dagar – Timme: 1–12 000 timmar – Minut: 1–72 000 minuter – Sekund: 1–9 999 999 sekunder Om intervallet till exempel är 6 och frekvensen är "Månad" är upprepningen var 6:e månad.

Valfritt

Property	Värde	Typ	Beskrivning
`headers`	<rubrikinnehåll>	JSON-objekt	Alla rubriker som du behöver inkludera med begäran Om du till exempel vill ange språk och typ: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
`queries`	<query-parameters>	JSON-objekt	Alla frågeparametrar som du behöver använda i begäran Till exempel `"queries": { "api-version": "2018-01-01" }` lägger objektet till `?api-version=2018-01-01` i begäran.
`body`	<body-content>	JSON-objekt	Meddelandeinnehållet som ska skickas som nyttolast med begäran
`authentication`	<authentication-type-and-property-values>	JSON-objekt	Den autentiseringsmodell som begäran använder för att autentisera utgående begäranden. Mer information finns i Lägga till autentisering i utgående anrop. Utöver Scheduler stöds egenskapen `authority` . När det inte anges är `https://management.azure.com/`standardvärdet , men du kan använda ett annat värde.
`retryPolicy` > `type`	<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
`runs`	<max-runs>	Integer	Som standard körs arbetsflödesinstanser samtidigt (samtidigt eller parallellt) upp till standardgränsen. Information om hur du ändrar den här gränsen genom att ange ett nytt <antal> värden finns i Ändra utlösarens samtidighet.
`maximumWaitingRuns`	<max-runs-queue>	Integer	När arbetsflödet redan kör det maximala antalet instanser, som du kan ändra baserat på `runtimeConfiguration.concurrency.runs` egenskapen, placeras alla nya körningar i den här kön upp till standardgränsen. Information om hur du ändrar standardgränsen finns i Ändra gränsen för väntande körningar.
`operationOptions`	<åtgärdsalternativ>	String	Du kan ändra standardbeteendet genom att ange egenskapen `operationOptions` . Mer information finns i Åtgärdsalternativ.

Utdata

Element	Typ	Beskrivning
`headers`	JSON-objekt	Rubrikerna från svaret
`body`	JSON-objekt	Brödtexten från svaret
`status code`	Integer	Statuskoden från svaret

Krav för inkommande begäranden

För att fungera bra med logikappen måste slutpunkten följa ett specifikt utlösarmönster eller kontrakt och identifiera följande svarsegenskaper:

Property	Obligatoriskt	Beskrivning
Statuskod	Ja	Statuskoden "200 OK" startar en körning. Någon annan statuskod startar inte en körning.
Försök efter nytt huvud	Nej	Antalet sekunder tills logikappen avsöker slutpunkten igen
Platsrubrik	Nej	Url:en som ska anropas vid nästa avsökningsintervall. Om den inte anges används den ursprungliga URL:en.

Exempelbeteenden för olika begäranden

Statuskod	Försök igen efter	Funktionssätt
200	{none}	Kör arbetsflödet och sök sedan igen efter mer data efter den definierade upprepningen.
200	10 sekund	Kör arbetsflödet och sök sedan igen efter mer data efter 10 sekunder.
202	60 sekunder	Utlös inte arbetsflödet. Nästa försök sker på en minut, med förbehåll för den definierade upprepningen. Om den definierade upprepningen är mindre än en minut har återförsökshuvudet företräde. Annars används den definierade upprepningen.
400	{none}	Felaktig begäran, kör inte arbetsflödet. Om nej `retryPolicy` har definierats används standardprincipen. När antalet återförsök har nåtts söker utlösaren igen efter data efter den definierade upprepningen.
500	{none}	Serverfel, kör inte arbetsflödet. Om nej `retryPolicy` har definierats används standardprincipen. När antalet återförsök har nåtts söker utlösaren igen efter data efter den definierade upprepningen.

HTTPWebhook-utlösare

Den här utlösaren gör logikappen anropsbar genom att skapa en slutpunkt som kan registrera en prenumeration genom att anropa den angivna slutpunkts-URL:en. När du skapar den här utlösaren i arbetsflödet gör en utgående begäran anropet för att registrera prenumerationen. På så sätt kan utlösaren börja lyssna efter händelser. När en åtgärd gör den här utlösaren ogiltig gör en utgående begäran automatiskt anropet för att avbryta prenumerationen. Mer information finns i Slutpunktsprenumerationer.

Du kan också ange asynkrona gränser för en HTTPWebhook-utlösare . Utlösarens beteende beror på vilka avsnitt du använder eller utelämnar.

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

Vissa värden, till exempel <metodtyp>, är tillgängliga för både objekten "subscribe" och "unsubscribe" .

Krävs

Värde	Typ	Beskrivning
<metodtyp>	String	HTTP-metoden som ska användas för prenumerationsbegäran: "GET", "PUT", "POST", "PATCH" eller "DELETE"
<endpoint-subscribe-URL>	String	Slutpunkts-URL:en där prenumerationsbegäran ska skickas

Valfritt

Värde	Typ	Beskrivning
<metodtyp>	String	HTTP-metoden som ska användas för annulleringsbegäran: "GET", "PUT", "POST", "PATCH" eller "DELETE"
<endpoint-unsubscribe-URL>	String	Slutpunkts-URL:en där begäran om annullering ska skickas
<body-content>	String	Meddelandeinnehåll som ska skickas i prenumerationen eller annulleringsbegäran
<authentication-type>	JSON-objekt	Den autentiseringsmodell som begäran använder för att autentisera utgående begäranden. Mer information finns i Lägga till autentisering i utgående anrop.
<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
<max-runs>	Integer	Som standard körs alla arbetsflödesinstanser samtidigt (samtidigt eller parallellt) upp till standardgränsen. Information om hur du ändrar den här gränsen genom att ange ett nytt <antal> värden finns i Ändra utlösarens samtidighet.
<max-runs-queue>	Integer	När arbetsflödet redan kör det maximala antalet instanser, som du kan ändra baserat på `runtimeConfiguration.concurrency.runs` egenskapen, placeras alla nya körningar i den här kön upp till standardgränsen. Information om hur du ändrar standardgränsen finns i Ändra gränsen för väntande körningar.
<åtgärdsalternativ>	String	Du kan ändra standardbeteendet genom att ange egenskapen `operationOptions` . Mer information finns i Åtgärdsalternativ.

Utdata

Element	Typ	Beskrivning
rubriker	JSON-objekt	Rubrikerna från svaret
brödtext	JSON-objekt	Brödtexten från svaret
statuskod	Integer	Statuskoden från svaret

Exempel

Den här utlösaren skapar en prenumeration på den angivna slutpunkten, tillhandahåller en unik återanrops-URL och väntar på nyligen publicerade teknikartiklar.

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

Återkomstutlösare

Den här utlösaren körs baserat på det angivna upprepningsschemat och ger ett enkelt sätt att skapa ett arbetsflöde som körs regelbundet.

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

Krävs

Värde	Typ	Beskrivning
<tidsenhet>	String	Den tidsenhet som beskriver hur ofta utlösaren utlöses: "Second", "Minute", "Hour", "Day", "Week", "Month"
<antal tidsenheter>	Integer	Ett värde som anger hur ofta utlösaren utlöses baserat på frekvensen, vilket är antalet tidsenheter som ska vänta tills utlösaren utlöses igen Här är de minsta och högsta intervallen: - Månad: 1–16 månader – Dag: 1–500 dagar – Timme: 1–12 000 timmar – Minut: 1–72 000 minuter – Sekund: 1–9 999 999 sekunder Om intervallet till exempel är 6 och frekvensen är "Månad" är upprepningen var 6:e månad.

Valfritt

Värde	Typ	Beskrivning
<start-date-time-with-format-YYYY-MM-DDThh:mm:ss>	String	Startdatum och tid i det här formatet: ÅÅÅÅ-MM-DDThh:mm:ss om du anger en tidszon -Eller- ÅÅÅÅ-MM-DDThh:mm:ssZ om du inte anger en tidszon Om du till exempel vill ha 18 september 2017 kl. 14:00 anger du "2017-09-18T14:00:00" och anger en tidszon som "Pacific Standard Time" eller anger "2017-09-18T14:00:00Z" utan tidszon. Obs! Den här starttiden har högst 49 år i framtiden och måste följa iso 8601-datumtidsspecifikationen i UTC-datumtidsformat, men utan utc-förskjutning. Om du inte anger en tidszon måste du lägga till bokstaven "Z" i slutet utan blanksteg. Detta "Z" avser motsvarande nautiska tid. För enkla scheman är starttiden den första förekomsten, medan utlösaren för komplexa scheman inte utlöses tidigare än starttiden. Mer information om startdatum och tider finns i Skapa och schemalägga aktiviteter som körs regelbundet.
<tidszon>	String	Gäller endast när du anger en starttid eftersom den här utlösaren inte accepterar UTC-förskjutning. Ange den tidszon som du vill använda.
<en eller flera timmes markeringar>	Heltals- eller heltalsmatris	Om du anger "Dag" eller "Vecka" för `frequency`kan du ange ett eller flera heltal från 0 till 23, avgränsade med kommatecken, som de timmar på dagen då du vill köra arbetsflödet. Om du till exempel anger "10", "12" och "14" får du 10 AM, 12 PM och 2 PM som timmarkeringar.
<en eller flera minuts markeringar>	Heltals- eller heltalsmatris	Om du anger "Dag" eller "Vecka" för `frequency`kan du ange ett eller flera heltal från 0 till 59, avgränsade med kommatecken, som minuter i timmen när du vill köra arbetsflödet. Du kan till exempel ange "30" som minutmarkering och med föregående exempel för timmar på dagen får du 10:30, 12:30 OCH 14:30.
weekDays	Sträng- eller strängmatris	Om du anger "Vecka" för `frequency`kan du ange en eller flera dagar, avgränsade med kommatecken, när du vill köra arbetsflödet: "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" och "Sunday"
<max-runs>	Integer	Som standard körs alla arbetsflödesinstanser samtidigt (samtidigt eller parallellt) upp till standardgränsen. Information om hur du ändrar den här gränsen genom att ange ett nytt <antal> värden finns i Ändra utlösarens samtidighet.
<max-runs-queue>	Integer	När arbetsflödet redan kör det maximala antalet instanser, som du kan ändra baserat på `runtimeConfiguration.concurrency.runs` egenskapen, placeras alla nya körningar i den här kön upp till standardgränsen. Information om hur du ändrar standardgränsen finns i Ändra gränsen för väntande körningar.
<åtgärdsalternativ>	String	Du kan ändra standardbeteendet genom att ange egenskapen `operationOptions` . Mer information finns i Åtgärdsalternativ.

Exempel 1

Den här grundläggande upprepningsutlösaren körs dagligen:

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

Exempel 2

Du kan ange startdatum och tid för att utlösaren ska utlösas. Den här upprepningsutlösaren startar på det angivna datumet och utlöses sedan dagligen:

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

Exempel 3

Den här upprepningsutlösaren startar den 9 september 2017 kl. 14:00 och utlöses varje vecka varje måndag kl. 10:30, 12:30 och 14:30 Pacific Standard Time:

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

Mer information plus exempel för den här utlösaren finns i Skapa och schemalägga aktiviteter som körs regelbundet.

Utlösare för begäran

Den här utlösaren gör logikappen anropsbar genom att skapa en slutpunkt som kan acceptera inkommande begäranden. För den här utlösaren anger du ett JSON-schema som beskriver och validerar nyttolasten eller indata som utlösaren tar emot från den inkommande begäran. Schemat gör även utlösaregenskaper enklare att referera till från senare åtgärder i arbetsflödet.

Om du vill anropa den här utlösaren måste du använda API:etlistCallbackUrl, som beskrivs i REST-API:et för arbetsflödestjänsten. Information om hur du använder den här utlösaren som en HTTP-slutpunkt finns i Anropa, utlösa eller kapsla arbetsflöden med HTTP-slutpunkter.

"manual": {
   "type": "Request",
   "kind": "Http",
   "inputs": {
      "method": "<method-type>",
      "relativePath": "<relative-path-for-accepted-parameter>",
      "schema": {
         "type": "object",
         "properties": { 
            "<property-name>": {
               "type": "<property-type>"
            }
         },
         "required": [ "<required-properties>" ]
      }
   },
   "runTimeConfiguration": {
      "concurrency": {
         "runs": <max-runs>,
         "maximumWaitingRuns": <max-run-queue>
      },
   },
   "operationOptions": "<operation-option>"
}

Krävs

Värde	Typ	Beskrivning
<egenskapsnamn>	String	Namnet på en egenskap i JSON-schemat, som beskriver nyttolasten
<egenskapstyp>	String	Egenskapens typ

Valfritt

Värde	Typ	Beskrivning
<metodtyp>	String	Den metod som inkommande begäranden måste använda för att anropa logikappen: "GET", "PUT", "POST", "PATCH", "DELETE"
<relative-path-for-accepted-parameter>	String	Den relativa sökvägen för parametern som slutpunktens URL kan acceptera
<obligatoriska egenskaper>	Matris	En eller flera egenskaper som kräver värden
<max-runs>	Integer	Som standard körs alla arbetsflödesinstanser samtidigt (samtidigt eller parallellt) upp till standardgränsen. Information om hur du ändrar den här gränsen genom att ange ett nytt <antal> värden finns i Ändra utlösarens samtidighet.
<max-runs-queue>	Integer	När arbetsflödet redan kör det maximala antalet instanser, som du kan ändra baserat på `runtimeConfiguration.concurrency.runs` egenskapen, placeras alla nya körningar i den här kön upp till standardgränsen. Information om hur du ändrar standardgränsen finns i Ändra gränsen för väntande körningar.
<åtgärdsalternativ>	String	Du kan ändra standardbeteendet genom att ange egenskapen `operationOptions` . Mer information finns i Åtgärdsalternativ.

Exempel

Den här utlösaren anger att en inkommande begäran måste använda HTTP POST-metoden för att anropa utlösaren och innehåller ett schema som validerar indata från den inkommande begäran:

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

Utlösande villkor

För alla utlösare och endast utlösare kan du inkludera en matris som innehåller ett eller flera uttryck för villkor som avgör om arbetsflödet ska köras. Om du vill lägga till conditions egenskapen i en utlösare i arbetsflödet öppnar du logikappen i kodvisningsredigeraren.

Du kan till exempel ange att en utlösare endast utlöses när en webbplats returnerar ett internt serverfel genom att referera till utlösarens statuskod i conditions egenskapen:

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

Som standard utlöses en utlösare först efter att ha fått svaret "200 OK". När ett uttryck refererar till statuskoden för en utlösare ersätts utlösarens standardbeteende. Om du vill att utlösaren ska utlösas för mer än en statuskod, till exempel statuskoden "200" och "201", måste du inkludera det här uttrycket som ditt villkor:

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

Utlösa flera körningar på en matris

Om utlösaren tar emot en matris som arbetsflödet ska bearbeta kan ibland en "för varje"-loop ta för lång tid att bearbeta varje matrisobjekt. I stället kan du använda egenskapen SplitOn i utlösaren för att diskutera matrisen. Debatching delar upp matrisobjekten och startar en ny arbetsflödesinstans som körs för varje matrisobjekt. Den här metoden är till exempel användbar när du vill avsöka en slutpunkt som kan returnera flera nya objekt mellan avsökningsintervall.

Om utlösarens Swagger-fil beskriver en nyttolast som är en matris läggs egenskapen SplitOn automatiskt till i utlösaren. Annars lägger du till den här egenskapen i svarsnyttolasten som har den matris som du vill diskutera.

Innan du använder SplitOn-funktionen bör du gå igenom följande överväganden:

Om samtidighet för utlösare är aktiverat minskas gränsen för SplitOn avsevärt. Om antalet objekt överskrider den här gränsen inaktiveras Funktionen SplitOn.
Du kan inte använda Funktionen SplitOn med ett synkront svarsmönster. Alla arbetsflöden som använder egenskapen SplitOn och innehåller en svarsåtgärd körs asynkront och skickar omedelbart ett 202 ACCEPTED svar.
Det maximala antalet matrisobjekt som SplitOn kan bearbeta i en enda arbetsflödeskörning finns i Gränser och konfiguration.

Exempel

Anta att du har en HTTP-utlösare som anropar ett API och tar emot det här svaret:

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

Arbetsflödet behöver bara innehållet från matrisen i Rows, så du kan skapa en utlösare som det här exemplet:

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

Kommentar

Om du använder SplitOn kommandot kan du inte hämta de egenskaper som finns utanför matrisen. I det här exemplet kan du därför inte hämta status egenskapen i svaret som returneras från API:et.

För att undvika ett fel om egenskapen Rows inte finns använder det här exemplet operatorn ? .

Arbetsflödesdefinitionen name kan nu användas @triggerBody().name för att hämta värdena, som kommer "customer-name-one" från den första körningen och "customer-name-two" från den andra körningen. Dina utlösarutdata ser alltså ut så här:

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

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

Åtgärdsöversikt

Azure Logic Apps innehåller olika åtgärdstyper – var och en med olika indata som definierar en åtgärds unika beteende. Åtgärderna har dessa högnivåelement, även om vissa är valfria:

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

Krävs

Värde	Typ	Beskrivning
<action-name>	String	Namnet på åtgärden
<åtgärdstyp>	String	Åtgärdstypen, till exempel "Http" eller "Api Anslut ion"
<input-name>	String	Namnet på en indata som definierar åtgärdens beteende
<input-value>	Olika	Indatavärdet, som kan vara en sträng, heltal, JSON-objekt och så vidare
<previous-trigger-or-action-status>	JSON-objekt	Namn och resulterande status för utlösaren eller åtgärden som måste köras omedelbart innan den aktuella åtgärden kan köras

Valfritt

Värde	Typ	Beskrivning
<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
<runtime-config-options>	JSON-objekt	För vissa åtgärder kan du ändra åtgärdens beteende vid körning genom att ange `runtimeConfiguration` egenskaper. Mer information finns i Konfigurationsinställningar för Körning.
<åtgärdsalternativ>	String	För vissa åtgärder kan du ändra standardbeteendet genom att `operationOptions` ange egenskapen . Mer information finns i Åtgärdsalternativ.

Lista över åtgärdstyper

Här är några vanliga åtgärdstyper:

Inbyggda åtgärdstyper som dessa exempel och mycket mer:
- HTTP för att anropa slutpunkter via HTTP eller HTTPS
- Svar för att svara på begäranden
- Köra JavaScript-kod för att köra JavaScript-kodfragment
- Funktion för att anropa Azure Functions
- Åtgärder för dataåtgärder som Join, Compose, Table, Select och andra som skapar eller transformerar data från olika indata
- Arbetsflöde för att anropa ett annat logikapparbetsflöde
Hanterade API-åtgärdstyper som Api Anslut ion och Api Anslut ionWebHook som anropar olika anslutningsappar och API:er som hanteras av Microsoft, till exempel Azure Service Bus, Office 365 Outlook, Power BI, Azure Blob Storage, OneDrive, GitHub med mera
Kontrollera arbetsflödesåtgärdstyper som If, Foreach, Switch, Scope och Until, som innehåller andra åtgärder och hjälper dig att organisera arbetsflödeskörning

Inbyggda åtgärder

Åtgärdstyp	beskrivning
Compose	Skapar en enda utdata från indata, som kan ha olika typer.
Köra JavaScript-kod	Kör JavaScript-kodfragment som passar in i specifika kriterier. Information om kodkrav och mer information finns i Lägga till och köra kodfragment med infogad kod.
Funktion	Anropar en Azure-funktion.
HTTP	Anropar en HTTP-slutpunkt.
Join	Skapar en sträng från alla objekt i en matris och separerar dessa objekt med ett angivet avgränsartecken.
Parsa JSON	Skapar användarvänliga token från egenskaper i JSON-innehåll. Du kan sedan referera till dessa egenskaper genom att inkludera token i logikappen.
Fråga	Skapar en matris från objekt i en annan matris baserat på ett villkor eller filter.
Response	Skapar ett svar på ett inkommande samtal eller en begäran.
Välj	Skapar en matris med JSON-objekt genom att transformera objekt från en annan matris baserat på den angivna kartan.
Tabell	Skapar en CSV- eller HTML-tabell från en matris.
Terminate	Stoppar ett aktivt arbetsflöde som körs.
Wait	Pausar arbetsflödet under en angiven varaktighet eller tills det angivna datumet och tiden.
Arbetsflöde	Kapslar ett arbetsflöde i ett annat arbetsflöde.

Hanterade API-åtgärder

Åtgärdstyp	beskrivning
ApiConnection	Anropar en HTTP-slutpunkt med hjälp av ett Microsoft-hanterat API.
Api Anslut ionWebhook	Fungerar som HTTP Webhook men använder ett Microsoft-hanterat API.

Kontrollera arbetsflödesåtgärder

De här åtgärderna hjälper dig att styra arbetsflödets körning och inkludera andra åtgärder. Utanför en kontrollarbetsflödesåtgärd kan du direkt referera till åtgärder i den kontrollarbetsflödesåtgärden. Om du till exempel har en Http åtgärd i ett omfång kan du referera till @body('Http') uttrycket var som helst i arbetsflödet. Åtgärder som finns i en kontrollarbetsflödesåtgärd kan dock bara "köras efter" andra åtgärder som finns i samma kontrollarbetsflödesstruktur.

Åtgärdstyp	beskrivning
Foreach	Kör samma åtgärder i en loop för varje objekt i en matris.
If	Kör åtgärder baserat på om det angivna villkoret är sant eller falskt.
Definitionsområde	Kör åtgärder baserat på gruppstatusen från en uppsättning åtgärder.
Växling	Kör åtgärder ordnade i fall då värden från uttryck, objekt eller token matchar de värden som anges av varje fall.
Tills	Kör åtgärder i en loop tills det angivna villkoret är sant.

Åtgärder – detaljerad referens

API Anslut ion-åtgärd

Den här åtgärden skickar en HTTP-begäran till ett Microsoft-hanterat API och kräver information om API:et och parametrarna plus en referens till en giltig anslutning.

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

Krävs

Värde	Typ	Beskrivning
<action-name>	String	Namnet på åtgärden som tillhandahålls av anslutningsappen
<api-name>	String	Namnet på det Microsoft-hanterade API som används för anslutningen
<metodtyp>	String	HTTP-metoden för att anropa API:et: "GET", "PUT", "POST", "PATCH" eller "DELETE"
<api-operation>	String	API-åtgärden som ska anropas

Valfritt

Värde	Typ	Beskrivning
<other-action-specific-input-properties>	JSON-objekt	Andra indataegenskaper som gäller för den här specifika åtgärden
<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
<query-parameters>	JSON-objekt	Alla frågeparametrar som ska inkluderas med API-anropet. Objektet lägger `?api-version=2018-01-01` till till `"queries": { "api-version": "2018-01-01" }` anropet.
<other-action-specific-properties>	JSON-objekt	Andra egenskaper som gäller för den här specifika åtgärden

Exempel

Den här definitionen beskriver åtgärden Skicka ett e-postmeddelande för Office 365 Outlook-anslutningsprogrammet, som är ett Microsoft-hanterat 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": {}
}

API Anslut ionWebhook-åtgärd

Den här åtgärden skickar en prenumerationsbegäran via HTTP till en slutpunkt med hjälp av ett Microsoft-hanterat API, tillhandahåller en motringnings-URL där slutpunkten kan skicka ett svar och väntar tills slutpunkten svarar. Mer information finns i Slutpunktsprenumerationer.

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

Vissa värden, till exempel <metodtyp>, är tillgängliga för både objekten "subscribe" och "unsubscribe" .

Krävs

Värde	Typ	Beskrivning
<action-name>	String	Namnet på åtgärden som tillhandahålls av anslutningsappen
<metodtyp>	String	HTTP-metoden som ska användas för att prenumerera eller avprenumerera från en slutpunkt: "GET", "PUT", "POST", "PATCH" eller "DELETE"
<api-subscribe-URL>	String	Den URI som ska användas för att prenumerera på API:et

Valfritt

Värde	Typ	Beskrivning
<api-unsubscribe-URL>	String	Den URI som ska användas för att avbryta prenumerationen från API:et
<rubrikinnehåll>	JSON-objekt	Alla rubriker som ska skickas i begäran Om du till exempel vill ange språket och skriva på en begäran: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
<body-content>	JSON-objekt	Allt meddelandeinnehåll som ska skickas i begäran
<authentication-type>	JSON-objekt	Den autentiseringsmodell som begäran använder för att autentisera utgående begäranden. Mer information finns i Lägga till autentisering i utgående anrop.
<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
<query-parameters>	JSON-objekt	Alla frågeparametrar som ska inkluderas med API-anropet Objektet lägger `?api-version=2018-01-01` till till `"queries": { "api-version": "2018-01-01" }` anropet.
<other-action-specific-input-properties>	JSON-objekt	Andra indataegenskaper som gäller för den här specifika åtgärden
<other-action-specific-properties>	JSON-objekt	Andra egenskaper som gäller för den här specifika åtgärden

Du kan också ange gränser för en Api Anslut ionWebhook-åtgärd på samma sätt som HTTP-asynkrona gränser.

Skapa åtgärd

Den här åtgärden skapar ett enda utdata från flera indata, inklusive uttryck. Både utdata och indata kan ha valfri typ som Azure Logic Apps har inbyggt stöd för, till exempel matriser, JSON-objekt, XML och binärt. Du kan sedan använda åtgärdens utdata i andra åtgärder.

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

Krävs

Värde	Typ	Beskrivning
<inputs-to-compose>	Alla	Indata för att skapa en enda utdata

Exempel 1

Den här åtgärdsdefinitionen sammanfogas abcdefg med ett avslutande blanksteg och värdet 1234:

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

Här är utdata som den här åtgärden skapar:

abcdefg 1234

Exempel 2

Den här åtgärdsdefinitionen sammanfogar en strängvariabel som innehåller abcdefg och en heltalsvariabel som innehåller 1234:

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

Här är utdata som den här åtgärden skapar:

"abcdefg1234"

Köra JavaScript Code-åtgärd

Den här åtgärden kör ett JavaScript-kodfragment och returnerar resultatet via en token som efterföljande åtgärder i arbetsflödet kan referera till.

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

Krävs

Värde	Typ	Beskrivning
<JavaScript-code-snippet>	Det varierar	Den JavaScript-kod som du vill köra. För kodkrav och mer information, se Kör kodfragment i arbetsflöden. `code` I attributet kan kodfragmentet använda det skrivskyddade `workflowContext` objektet som indata. Det här objektet har underegenskaper som ger koden åtkomst till utdata från utlösaren och eventuella föregående åtgärder i arbetsflödet. Mer information om objektet finns i `workflowContext` Referensutlösare och åtgärdsresultat med hjälp av workflowContext-objektet.

Krävs i vissa fall

Attributet explicitDependencies anger att du uttryckligen vill inkludera resultat från utlösaren, tidigare åtgärder eller båda som beroenden för kodfragmentet. Mer information om hur du lägger till dessa beroenden finns i Lägga till beroenden som parametrar i en infogad kodåtgärd.

För attributet includeTrigger kan du ange true eller false värden.

Värde	Typ	Beskrivning
<föregående åtgärder>	Strängmatris	En matris med åtgärdsnamnen i JSON-format som beroenden. Se till att använda de åtgärdsnamn som visas i arbetsflödesdefinitionen där åtgärdsnamn använder understreck (_), inte blanksteg (" ").

Exempel 1

Den här åtgärden kör kod som hämtar logikappens arbetsflödesnamn och returnerar texten "Hello world from <logic-app-name>" som resultat. I det här exemplet refererar koden till arbetsflödets namn genom att komma åt egenskapen via det skrivskyddade workflowContext.workflow.name workflowContext objektet. Mer information om hur du använder workflowContext objektet finns i Referensutlösare och åtgärdsresultat i koden.

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

Exempel 2

Den här åtgärden kör kod i ett logikapparbetsflöde som utlöses när ett nytt e-postmeddelande kommer till ett Outlook-konto. Arbetsflödet använder också e-poståtgärden Skicka godkännande för Office 365 Outlook som vidarebefordrar innehållet från det mottagna e-postmeddelandet tillsammans med en begäran om godkännande.

Koden extraherar e-postadresserna från e-postmeddelandets Body egenskap och returnerar adresserna tillsammans med egenskapsvärdet SelectedOption från godkännandeåtgärden. Åtgärden innehåller uttryckligen åtgärden Skicka e-postgodkännande som ett beroende i actions objektet i explicitDependencies objektet.

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

Funktionsåtgärd

Den här åtgärden anropar en tidigare skapad Azure-funktion.

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

Krävs

Värde	Typ	Beskrivning
<Azure-function-ID>	String	Resurs-ID:t för den Azure-funktion som du vill anropa. Här är formatet för det här värdet: "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group>/providers/Microsoft.Web/sites/<Azure-function-app-name>/functions/<Azure-function-name>"
<metodtyp>	String	HTTP-metoden som ska användas för att anropa funktionen: "GET", "PUT", "POST", "PATCH" eller "DELETE" Om det inte anges är standardinställningen "POST"-metoden.

Valfritt

Värde	Typ	Beskrivning
<rubrikinnehåll>	JSON-objekt	Alla rubriker som ska skickas med anropet Om du till exempel vill ange språket och skriva på en begäran: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
<body-content>	JSON-objekt	Allt meddelandeinnehåll som ska skickas i begäran
<query-parameters>	JSON-objekt	Alla frågeparametrar som ska inkluderas med API-anropet Objektet lägger `?api-version=2018-01-01` till till `"queries": { "api-version": "2018-01-01" }` anropet.
<other-action-specific-input-properties>	JSON-objekt	Andra indataegenskaper som gäller för den här specifika åtgärden
<other-action-specific-properties>	JSON-objekt	Andra egenskaper som gäller för den här specifika åtgärden

När du sparar logikappen utför Azure Logic Apps dessa kontroller på den refererade funktionen:

Arbetsflödet måste ha åtkomst till funktionen.
Arbetsflödet kan bara använda en HTTP-standardutlösare eller en allmän JSON-webhook-utlösare.

Azure Logic Apps hämtar och cachelagrar utlösarens URL, som används vid körning. Men om någon åtgärd ogiltigförklarar den cachelagrade URL:en misslyckas funktionsåtgärden vid körning. Du kan åtgärda det här problemet genom att spara logikappen igen så att logikappen hämtar och cachelagrar utlösar-URL:en igen.
Funktionen kan inte ha någon väg definierad.
Endast "funktions" och "anonyma" auktoriseringsnivåer tillåts.

Exempel

Den här åtgärdsdefinitionen anropar funktionen "GetProductID" som skapades tidigare:

"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-åtgärd

Den här åtgärden skickar en begäran till den angivna HTTP- eller HTTPS-slutpunkten och kontrollerar svaret för att avgöra om arbetsflödet körs. Mer information finns i Anropa tjänstslutpunkter via HTTP eller HTTPS från 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": {}
}

Krävs

Property	Värde	Typ	Beskrivning
`method`	<metodtyp>	String	Den metod som ska användas för att skicka den utgående begäran: "GET", "PUT", "POST", "PATCH" eller "DELETE"
`uri`	<HTTP-or-HTTPS-endpoint-URL>	String	HTTP- eller HTTPS-slutpunkts-URL:en där du vill skicka den utgående begäran. Maximal strängstorlek: 2 KB För en Azure-tjänst eller resurs innehåller den här URI-syntaxen resurs-ID:t och sökvägen till den resurs som du vill komma åt.

Valfritt

Property	Värde	Typ	Beskrivning
`headers`	<rubrikinnehåll>	JSON-objekt	Alla rubriker som du behöver inkludera med begäran Om du till exempel vill ange språk och typ: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
`queries`	<query-parameters>	JSON-objekt	Alla frågeparametrar som du behöver använda i begäran Objektet lägger `?api-version=2018-01-01` till till `"queries": { "api-version": "2018-01-01" }` anropet.
`body`	<body-content>	JSON-objekt	Meddelandeinnehållet som ska skickas som nyttolast med begäran
`authentication`	<authentication-type-and-property-values>	JSON-objekt	Den autentiseringsmodell som begäran använder för att autentisera utgående begäranden. Mer information finns i Lägga till autentisering i utgående anrop. Utöver Scheduler stöds egenskapen `authority` . När det inte anges är `https://management.azure.com/`standardvärdet , men du kan använda ett annat värde.
`retryPolicy` > `type`	<återförsöksbeteende>	JSON-objekt	Anpassar återförsöksbeteendet för tillfälliga fel, som har statuskoden 408, 429 och 5XX och eventuella anslutningsfel. Mer information finns i Återförsöksprinciper.
<other-action-specific-input-properties>	<input-property>	JSON-objekt	Andra indataegenskaper som gäller för den här specifika åtgärden
<other-action-specific-properties>	<egenskapsvärde>	JSON-objekt	Andra egenskaper som gäller för den här specifika åtgärden

Exempel

Den här åtgärdsdefinitionen hämtar de senaste nyheterna genom att skicka en begäran till den angivna slutpunkten:

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

Åtgärden anslut

Den här åtgärden skapar en sträng från alla objekt i en matris och separerar dessa objekt med det angivna avgränsartecknet.

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

Krävs

Värde	Typ	Beskrivning
<Array>	Matris	Matrisen eller uttrycket som tillhandahåller källobjekten. Om du anger ett uttryck omger du uttrycket med dubbla citattecken.
<Avgränsare>	Sträng med ett tecken	Tecknet som separerar varje objekt i strängen

Exempel

Anta att du har en tidigare skapad "myIntegerArray"-variabel som innehåller den här heltalsmatrisen:

[1,2,3,4]

Den här åtgärdsdefinitionen hämtar värdena från variabeln med hjälp variables() av funktionen i ett uttryck och skapar den här strängen med dessa värden, som avgränsas med ett kommatecken: "1,2,3,4"

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

Parsa JSON-åtgärd

Den här åtgärden skapar användarvänliga fält eller token från egenskaperna i JSON-innehåll. Du kan sedan komma åt dessa egenskaper i logikappen med hjälp av token i stället. När du till exempel vill använda JSON-utdata från tjänster som Azure Service Bus och Azure Cosmos DB kan du inkludera den här åtgärden i logikappen så att du enklare kan referera till data i dessa utdata.

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

Krävs

Värde	Typ	Beskrivning
<JSON-källa>	JSON-objekt	Det JSON-innehåll som du vill parsa
<JSON-schema>	JSON-objekt	JSON-schemat som beskriver det underliggande JSON-innehållet, som åtgärden använder för att parsa JSON-källinnehållet. Tips: I arbetsflödesdesignern kan du antingen ange schemat eller ange en exempelnyttolast så att åtgärden kan generera schemat.

Exempel

Den här åtgärdsdefinitionen skapar dessa token som du kan använda i arbetsflödet, men bara i åtgärder som körs efter åtgärden Parsa JSON :

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

I det här exemplet anger egenskapen "content" JSON-innehållet för åtgärden som ska parsas. Du kan också ange det här JSON-innehållet som exempelnyttolast för att generera schemat.

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

Egenskapen "schema" anger det JSON-schema som används för att beskriva JSON-innehållet:

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

Frågeåtgärd

Den här åtgärden skapar en matris från objekt i en annan matris baserat på ett angivet villkor eller filter.

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

Krävs

Värde	Typ	Beskrivning
<Array>	Matris	Matrisen eller uttrycket som tillhandahåller källobjekten. Om du anger ett uttryck omger du uttrycket med dubbla citattecken.
<condition-or-filter>	String	Villkoret som används för att filtrera objekt i källmatrisen Obs! Om inga värden uppfyller villkoret skapar åtgärden en tom matris.

Exempel

Den här åtgärdsdefinitionen skapar en matris som har värden som är större än det angivna värdet, vilket är två:

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

Response action

Den här åtgärden skapar nyttolasten för svaret på en HTTP-begäran.

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

Krävs

Värde	Typ	Beskrivning
<response-status-code>	Integer	HTTP-statuskoden som skickas till den inkommande begäran. Standardkoden är "200 OK", men koden kan vara valfri giltig statuskod som börjar med 2xx, 4xx eller 5xx, men inte med 3xxx.

Valfritt

Värde	Typ	Beskrivning
<svarshuvuden>	JSON-objekt	En eller flera rubriker som ska inkluderas i svaret
<svarstext>	Olika	Svarstexten, som kan vara en sträng, ett JSON-objekt eller till och med binärt innehåll från en tidigare åtgärd

Exempel

Den här åtgärdsdefinitionen skapar ett svar på en HTTP-begäran med angiven statuskod, meddelandetext och meddelandehuvuden:

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

Begränsningar

Till skillnad från andra åtgärder har åtgärden Svar särskilda begränsningar:

Arbetsflödet kan endast använda åtgärden Svar när arbetsflödet börjar med en HTTP-begärandeutlösare, vilket innebär att arbetsflödet måste utlösas av en HTTP-begäran.
Arbetsflödet kan använda åtgärden Svar var som helst utom i Foreach-loopar , Until-loopar , inklusive sekventiella loopar och parallella grenar.
Den ursprungliga begäran hämtar endast arbetsflödets svar när alla åtgärder som krävs av åtgärden Svar har slutförts inom tidsgränsen för HTTP.

Men om arbetsflödet anropar en annan logikapp som ett kapslat arbetsflöde väntar det överordnade arbetsflödet tills det kapslade arbetsflödet har slutförts, oavsett hur lång tid det tar innan det kapslade arbetsflödet är klart.
När arbetsflödet använder åtgärden Svar och ett synkront svarsmönster kan arbetsflödet inte heller använda kommandot splitOn i utlösardefinitionen eftersom kommandot skapar flera körningar. Kontrollera det här fallet när PUT-metoden används och returnera ett svar om det är sant.

Annars, om arbetsflödet använder kommandot splitOn och en svarsåtgärd , körs arbetsflödet asynkront och returnerar omedelbart svaret "202 ACCEPTED".
När arbetsflödets körning når åtgärden Svar , men den inkommande begäran redan har fått ett svar, markeras åtgärden Svar som "Misslyckades" på grund av konflikten. Därför markeras även logikappkörningen med statusen "Misslyckades".

Välj åtgärd

Den här åtgärden skapar en matris med JSON-objekt genom att transformera objekt från en annan matris baserat på den angivna kartan. Utdatamatrisen och källmatrisen har alltid samma antal objekt. Även om du inte kan ändra antalet objekt i utdatamatrisen kan du lägga till eller ta bort egenskaper och deras värden i dessa objekt. Egenskapen select anger minst ett nyckel/värde-par som definierar kartan för att transformera objekt i källmatrisen. Ett nyckel/värde-par representerar en egenskap och dess värde för alla objekt i utdatamatrisen.

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

Krävs

Värde	Typ	Beskrivning
<Array>	Matris	Matrisen eller uttrycket som tillhandahåller källobjekten. Se till att du omger ett uttryck med dubbla citattecken. Obs! Om källmatrisen är tom skapar åtgärden en tom matris.
<nyckelnamn>	String	Egenskapsnamnet som tilldelats resultatet från <uttrycket> Om du vill lägga till en ny egenskap för alla objekt i utdatamatrisen anger du ett <nyckelnamn> för den egenskapen och ett< uttryck> för egenskapsvärdet. Om du vill ta bort en egenskap från alla objekt i matrisen utelämnar <du nyckelnamnet> för den egenskapen.
<Uttryck>	String	Uttrycket som transformerar objektet i källmatrisen och tilldelar resultatet till <nyckelnamn>

Åtgärden Välj skapar en matris som utdata, så alla åtgärder som vill använda dessa utdata måste antingen acceptera en matris, eller så måste du konvertera matrisen till den typ som konsumentåtgärden accepterar. Om du till exempel vill konvertera utdatamatrisen till en sträng kan du skicka matrisen till åtgärden Skriv och sedan referera till utdata från åtgärden Skriv i dina andra åtgärder.

Exempel

Den här åtgärdsdefinitionen skapar en JSON-objektmatris från en heltalsmatris. Åtgärden itererar genom källmatrisen, hämtar varje heltalsvärde med hjälp @item() av uttrycket och tilldelar varje värde till egenskapen "number" i varje JSON-objekt:

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

Här är matrisen som den här åtgärden skapar:

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

Om du vill använda den här matrisens utdata i andra åtgärder skickar du dessa utdata till en Skriv-åtgärd :

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

Du kan sedan använda utdata från åtgärden Skriv i dina andra åtgärder, till exempel Office 365 Outlook – Skicka en e-poståtgärd :

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

Tabellåtgärd

Den här åtgärden skapar en CSV- eller HTML-tabell från en matris. För matriser med JSON-objekt skapar den här åtgärden automatiskt kolumnrubrikerna från objektens egenskapsnamn. För matriser med andra datatyper måste du ange kolumnrubriker och värden. Den här matrisen innehåller till exempel egenskaperna "ID" och "Product_Name" som den här åtgärden kan använda för kolumnrubriknamnen:

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

Krävs

Värde	Typ	Beskrivning
<CSV eller HTML>	String	Formatet för tabellen som du vill skapa
<Array>	Matris	Matrisen eller uttrycket som tillhandahåller källobjekten för tabellen Obs! Om källmatrisen är tom skapar åtgärden en tom tabell.

Valfritt

Om du vill ange eller anpassa kolumnrubriker och värden använder du matrisen columns . När header-value par har samma rubriknamn visas deras värden i samma kolumn under det rubriknamnet. Annars definierar varje unik rubrik en unik kolumn.

Värde	Typ	Beskrivning
<column-name>	String	Rubriknamnet för en kolumn
<column-value>	Alla	Värdet i kolumnen

Exempel 1

Anta att du har en tidigare skapad "myItemArray"-variabel som för närvarande innehåller den här matrisen:

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

Den här åtgärdsdefinitionen skapar en CSV-tabell från variabeln "myItemArray". Uttrycket som används av from egenskapen hämtar matrisen från "myItemArray" med hjälp variables() av funktionen:

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

Här är CSV-tabellen som den här åtgärden skapar:

ID,Product_Name 
0,Apples 
1,Oranges

Exempel 2

Den här åtgärdsdefinitionen skapar en HTML-tabell från variabeln "myItemArray". Uttrycket som används av from egenskapen hämtar matrisen från "myItemArray" med hjälp variables() av funktionen:

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

Här är HTML-tabellen som den här åtgärden skapar:

ID	Product_name
0	Äpplen
1	Apelsiner

Exempel 3

Den här åtgärdsdefinitionen skapar en HTML-tabell från variabeln "myItemArray". I det här exemplet åsidosätts dock standardnamnen för kolumnrubriker med "Stock_ID" och "Beskrivning" och lägger till ordet "Organisk" i värdena i kolumnen "Beskrivning".

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

Här är HTML-tabellen som den här åtgärden skapar:

Stock_ID	beskrivning
0	Ekologiska äpplen
1	Ekologiska apelsiner

Avsluta åtgärd

Den här åtgärden stoppar körningen för en arbetsflödesinstans, avbryter pågående åtgärder, hoppar över eventuella återstående åtgärder och returnerar den angivna statusen. Du kan till exempel använda åtgärden Avsluta när logikappen måste avslutas helt från ett feltillstånd. Den här åtgärden påverkar inte redan slutförda åtgärder och kan inte visas i Foreach - och Until-loopar , inklusive sekventiella loopar.

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

Krävs

Värde	Typ	Beskrivning
<status>	String	Statusen som ska returneras för körningen: "Failed", "Cancelled" eller "Succeeded"

Valfritt

Egenskaperna för objektet "runStatus" gäller endast när egenskapen "runStatus" är inställd på statusen "Misslyckades".

Värde	Typ	Beskrivning
<error-code-or-name>	String	Koden eller namnet på felet
<felmeddelande>	String	Meddelandet eller texten som beskriver felet och alla åtgärder som appanvändaren kan vidta

Exempel

Den här åtgärdsdefinitionen stoppar en arbetsflödeskörning, anger körningsstatusen till "Misslyckades" och returnerar status, en felkod och ett felmeddelande:

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

Vänta-åtgärd

Den här åtgärden pausar arbetsflödeskörningen för det angivna intervallet eller till den angivna tiden, men inte båda.

Angivet intervall

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

Angiven tid

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

Krävs

Värde	Typ	Beskrivning
<antal enheter>	Integer	För åtgärden Fördröjning kan antalet enheter som ska vänta
<interval>	String	För åtgärden Fördröjning väntar intervallet: "Second", "Minute", "Hour", "Day", "Week", "Month"
<datum-tid-stämpel>	String	För åtgärden Fördröj tills , datum och tid för att återuppta körningen. Det här värdet måste använda UTC-datumtidsformatet.

Exempel 1

Den här åtgärdsdefinitionen pausar arbetsflödet i 15 minuter:

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

Exempel 2

Den här åtgärdsdefinitionen pausar arbetsflödet tills den angivna tiden:

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

Arbetsflödesåtgärd

Den här åtgärden anropar en annan tidigare skapad logikapp, vilket innebär att du kan inkludera och återanvända andra arbetsflöden för logikappar. Du kan också använda utdata från den underordnade eller kapslade logikappen i åtgärder som följer den kapslade logikappen, förutsatt att den underordnade logikappen returnerar ett svar.

Azure Logic Apps kontrollerar åtkomsten till utlösaren som du vill anropa, så se till att du kan komma åt utlösaren. Dessutom måste den kapslade logikappen uppfylla följande kriterier:

En utlösare gör den kapslade logikappen anropsbar, till exempel en begäran eller HTTP-utlösare
Samma Azure-prenumeration som din överordnade logikapp
Om du vill använda utdata från den kapslade logikappen i den överordnade logikappen måste den kapslade logikappen ha en svarsåtgärd

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

Krävs

Värde	Typ	Beskrivning
<nested-logic-app-name>	String	Namnet på logikappen som du vill anropa
<trigger-name>	String	Namnet på utlösaren i den kapslade logikappen som du vill anropa
<Azure-subscription-ID>	String	Azure-prenumerations-ID för den kapslade logikappen
<Azure-resursgrupp>	String	Namnet på Azure-resursgruppen för den kapslade logikappen

Valfritt

Värde	Typ	Beskrivning
<rubrikinnehåll>	JSON-objekt	Alla rubriker som ska skickas med anropet
<body-content>	JSON-objekt	Allt meddelandeinnehåll som ska skickas med samtalet

Utdata

Den här åtgärdens utdata varierar beroende på den kapslade logikappens svarsåtgärd. Om den kapslade logikappen inte innehåller en svarsåtgärd är utdata tomma.

Exempel

När åtgärden "Start_search" har slutförts anropar den här arbetsflödesåtgärdsdefinitionen en annan logikapp med namnet "Get_product_information", som skickar in de angivna indata:

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

Kontrollera arbetsflödesåtgärdsinformation

Foreach-åtgärd

Den här loopåtgärden itererar genom en matris och utför åtgärder på varje matrisobjekt. Som standard körs loopen "för varje" parallellt upp till ett maximalt antal loopar. Det här maxvärdet finns i Gränser och konfiguration. Lär dig hur du skapar "för varje" loopar.

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

Krävs

Värde	Typ	Beskrivning
<action-1... N>	String	Namnen på de åtgärder som körs på varje matrisobjekt
<action-definition-1... N>	JSON-objekt	Definitionerna av de åtgärder som körs
<for-each-expression>	String	Uttrycket som refererar till varje objekt i den angivna matrisen

Valfritt

Värde	Typ	Beskrivning
<antal>	Integer	Som standard körs "för varje" loop-iterationer samtidigt (samtidigt eller parallellt) upp till standardgränsen. Information om hur du ändrar den här gränsen genom att ange ett nytt <antal> värden finns i Ändra samtidighet för varje loop.
<åtgärdsalternativ>	String	Om du vill köra en "för varje"-loop sekventiellt i stället för parallellt anger du antingen <åtgärdsalternativet> till `Sequential` eller< räkna> till `1`, men inte båda. Mer information finns i Kör "för varje" loopar sekventiellt.

Exempel

Den här loopen "för varje" skickar ett e-postmeddelande för varje objekt i matrisen, som innehåller bifogade filer från ett inkommande e-postmeddelande. Loopen skickar ett e-postmeddelande, inklusive den bifogade filen, till en person som granskar den bifogade filen.

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

Om du bara vill ange en matris som skickas som utdata från utlösaren hämtar det här uttrycket matrisens <namnmatris> från utlösartexten. För att undvika ett fel om matrisen inte finns använder uttrycket operatorn ? :

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

Om åtgärden

Den här åtgärden, som är en villkorsstyrd instruktion, utvärderar ett uttryck som representerar ett villkor och kör en annan gren baserat på om villkoret är sant eller falskt. Om villkoret är sant markeras villkoret med statusen "Lyckades". Lär dig hur du skapar villkorsstyrda instruktioner.

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

Värde	Typ	Beskrivning
<Villkor>	JSON-objekt	Villkoret, som kan vara ett uttryck, för att utvärdera
<action-1>	JSON-objekt	Åtgärden som ska köras när <villkoret> utvärderas till sant
<åtgärdsdefinition>	JSON-objekt	Definitionen för åtgärden
<action-2>	JSON-objekt	Åtgärden som ska köras när <villkoret> utvärderas till falskt

Åtgärderna i objekten actions eller else får följande statusar:

"Lyckades" när de körs och lyckas
"Misslyckades" när de kördes och misslyckades
"Hoppades över" när respektive gren inte körs

Exempel

Det här villkoret anger att när heltalsvariabeln har ett värde större än noll kontrollerar arbetsflödet en webbplats. Om variabeln är noll eller mindre kontrollerar arbetsflödet en annan webbplats.

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

Hur villkor använder uttryck

Här är några exempel som visar hur du kan använda uttryck i villkor:

JSON	Result
"expression": "@parameters('<hasSpecialAction>')"	Endast för booleska uttryck skickas villkoret för alla värden som utvärderas till true. Om du vill konvertera andra typer till boolesk använder du följande funktioner: `empty()` eller `equals()`.
"expression": "@greater(actions('action>'<).output.value, parameters('<threshold>'))"	För jämförelsefunktioner körs åtgärden endast när utdata från <åtgärden> är mer än <tröskelvärdet.>
"expression": "@or(greater(actions('action>'<).output.value, parameters('<threshold>')), less(actions('<same-action>').output.value, 100))"	För logikfunktioner och skapande av kapslade booleska uttryck körs åtgärden när utdata från <åtgärden> är mer än <tröskelvärdet> eller under 100.
"expression": "@equals(length(actions('action>'<).outputs.errors), 0)"	Du kan använda matrisfunktioner för att kontrollera om matrisen har några objekt. Åtgärden körs när matrisen `errors` är tom.

Omfångsåtgärd

Den här åtgärden grupperar logiskt åtgärder i omfång, som får sin egen status när åtgärderna i omfånget har slutförts. Du kan sedan använda omfångets status för att avgöra om andra åtgärder körs. Lär dig hur du skapar omfång.

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

Krävs

Värde	Typ	Beskrivning
<inner-action-1... N>	JSON-objekt	En eller flera åtgärder som körs inom omfånget
<action-inputs>	JSON-objekt	Indata för varje åtgärd

Växelåtgärd

Den här åtgärden, även kallad switch-instruktion, organiserar andra åtgärder i ärenden och tilldelar ett värde till varje ärende, förutom standardfallet om det finns en sådan. När arbetsflödet körs jämför switch-åtgärden värdet från ett uttryck, ett objekt eller en token med de värden som anges för varje ärende. Om switch-åtgärden hittar ett matchande ärende kör arbetsflödet endast åtgärderna för det fallet. Varje gång switch-åtgärden körs finns antingen bara ett matchande ärende eller så finns inga matchningar. Om det inte finns några matchningar kör switch-åtgärden standardåtgärderna. Lär dig hur du skapar switch-instruktioner.

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

Krävs

Värde	Typ	Beskrivning
<expression-object-or-token>	Det varierar	Uttrycket, JSON-objektet eller token som ska utvärderas
<action-name>	String	Namnet på den åtgärd som ska köras för matchande ärende
<åtgärdsdefinition>	JSON-objekt	Definitionen för åtgärden som ska köras för matchande ärende
<matchningsvärde>	Det varierar	Det värde som ska jämföras med det utvärderade resultatet

Valfritt

Värde	Typ	Beskrivning
<default-action-name>	String	Namnet på standardåtgärden som ska köras när det inte finns något matchande ärende
<default-action-definition>	JSON-objekt	Definitionen för åtgärden som ska köras när det inte finns något matchande ärende

Exempel

Den här åtgärdsdefinitionen utvärderar om den person som svarar på e-postmeddelandet för godkännandebegäran valde alternativet "Godkänn" eller alternativet "Avvisa". Baserat på det här valet kör switch-åtgärden åtgärderna för matchningsfallet, vilket är att skicka ett annat e-postmeddelande till svararen men med olika formuleringar i varje enskilt fall.

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

Tills åtgärden har åtgärd

Den här loopåtgärden innehåller åtgärder som körs tills det angivna villkoret är sant. Loopen kontrollerar villkoret som det sista steget när alla andra åtgärder har körts. Du kan inkludera fler än en åtgärd i "actions" objektet och åtgärden måste definiera minst en gräns. Lär dig hur du skapar "till"-loopar.

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

Värde	Typ	Beskrivning
<action-name>	String	Namnet på den åtgärd som du vill köra i loopen
<åtgärdstyp>	String	Den åtgärdstyp som du vill köra
<action-inputs>	Olika	Indata för åtgärden som ska köras
<Villkor>	String	Villkoret eller uttrycket som ska utvärderas efter att alla åtgärder i loopen har körts
<loop-count>	Integer	Gränsen för det högsta antalet loopar som åtgärden kan köra. Mer information om standardgränsen och maxgränsen finns i Gränser och konfiguration för Azure Logic Apps.
<loop-timeout>	String	Gränsen för den längsta tid som loopen kan köras. `timeout` Standardvärdet är `PT1H`, vilket är det iso 8601-format som krävs.

Kommentar

Om uttrycket är beroende av utdata från någon åtgärd i Until-loopen kontrollerar du att du tar hänsyn till eventuella fel som uppstår från den åtgärden.

Exempel

Den här loopåtgärdsdefinitionen skickar en HTTP-begäran till den angivna URL:en tills något av dessa villkor uppfylls:

Begäran hämtar ett svar med statuskoden "200 OK".
Loopen har körts 60 gånger.
Loopen har körts i en timme.

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

Webhook-baserade utlösare och åtgärder kontrollerar inte slutpunkter regelbundet, utan väntar i stället på specifika händelser eller data vid dessa slutpunkter. Dessa utlösare och åtgärder prenumererar på slutpunkterna genom att ange en motringnings-URL där slutpunkten kan skicka svar.

Anropet subscribe sker när arbetsflödet ändras på något sätt, till exempel när autentiseringsuppgifterna förnyas eller när indataparametrarna ändras för en utlösare eller åtgärd. Det här anropet använder samma parametrar som http-standardåtgärder.

Anropet unsubscribe sker automatiskt när en åtgärd gör utlösaren eller åtgärden ogiltig, till exempel:

Ta bort eller inaktivera utlösaren.
Ta bort eller inaktivera arbetsflödet.
Ta bort eller inaktivera prenumerationen.

För att stödja dessa anrop @listCallbackUrl() returnerar uttrycket en unik "motringnings-URL" för utlösaren eller åtgärden. Den här URL:en representerar en unik identifierare för slutpunkterna som använder tjänstens REST API. Parametrarna för den här funktionen är samma som webhookens utlösare eller åtgärd.

Ändra asynkron varaktighet

För både utlösare och åtgärder kan du begränsa varaktigheten för det asynkrona mönstret till ett visst tidsintervall genom att lägga till limit.timeout egenskapen. På så sätt, om åtgärden inte har slutförts när intervallet upphör att gälla, markeras åtgärdens status som Cancelled med ActionTimedOut koden. Egenskapen timeout använder ISO 8601-format.

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

Konfigurationsinställningar för körning

Du kan ändra standardbeteendet för körning för utlösare och åtgärder genom att lägga till dessa runtimeConfiguration egenskaper i utlösaren eller åtgärdsdefinitionen.

Property	Type	Beskrivning	Utlösare eller åtgärd
`runtimeConfiguration.concurrency.runs`	Integer	Ändra standardgränsen för antalet arbetsflödesinstanser som kan köras samtidigt (samtidigt eller parallellt). Om du justerar det här värdet kan du begränsa antalet begäranden som serverdelssystemen tar emot. Att ställa in egenskapen `runs` på `1` fungerar på samma sätt som att ställa in egenskapen `operationOptions` på `SingleInstance`. Du kan ange någon av egenskaperna, men inte båda. Information om hur du ändrar standardgränsen finns i Ändra samtidighet för utlösare eller utlösarinstanser sekventiellt.	Alla utlösare
`runtimeConfiguration.concurrency.maximumWaitingRuns`	Integer	Ändra standardgränsen för antalet arbetsflödesinstanser som måste vänta med att köras när logikappen redan kör de maximala samtidiga instanserna. Information om hur du ändrar standardgränsen finns i Ändra gränsen för väntande körningar.	Alla utlösare
`runtimeConfiguration.concurrency.repetitions`	Integer	Ändra standardgränsen för antalet "för varje" loop-iterationer som kan köras samtidigt (samtidigt eller parallellt). Att ställa in egenskapen `repetitions` på `1` fungerar på samma sätt som att ställa in egenskapen `operationOptions` på `SingleInstance`. Du kan ange någon av egenskaperna, men inte båda. Om du vill ändra standardgränsen läser du Ändra "för varje" samtidighet eller Kör "för varje"-loopar sekventiellt.	Åtgärder: Foreach
`runtimeConfiguration.paginationPolicy.minimumItemCount`	Integer	För specifika åtgärder som stöder och har sidnumrering aktiverat anger det här värdet det minsta antalet resultat som ska hämtas. Information om hur du aktiverar sidnumrering finns i Hämta massdata, objekt eller resultat med hjälp av sidnumrering	Åtgärd: Varierad
`runtimeConfiguration.secureData.properties`	Matris	På många utlösare och åtgärder döljer de här inställningarna indata, utdata eller båda från logikappens körningshistorik. Mer information om hur du skyddar dessa data finns i Dölj indata och utdata från körningshistorik.	De flesta utlösare och åtgärder
`runtimeConfiguration.staticResult`	JSON-objekt	För åtgärder som stöder och har inställningen för statiskt resultat aktiverat har `staticResult` objektet följande attribut: - `name`, som refererar till den aktuella åtgärdens namn på den statiska resultatdefinitionen `staticResults` , som visas i attributet i logikappens arbetsflödesattribut `definition` . Mer information finns i Statiska resultat – Schemareferens för arbetsflödesdefinitionsspråk. - `staticResultOptions`, som anger om statiska resultat är `Enabled` för den aktuella åtgärden eller inte. Information om hur du aktiverar statiska resultat finns i Testa logikappar med falska data genom att konfigurera statiska resultat	Åtgärd: Varierad

Åtgärdsalternativ

Du kan ändra standardbeteendet för utlösare och åtgärder med operationOptions egenskapen i utlösar- eller åtgärdsdefinitionen.

Åtgärdsalternativ	Typ	Beskrivning	Utlösare eller åtgärd
`DisableAsyncPattern`	String	Kör HTTP-baserade åtgärder synkront i stället för asynkront. Information om hur du anger det här alternativet finns i Kör åtgärder synkront.	Åtgärder: Api Anslut ion, HTTP, Response
`IncludeAuthorizationHeadersInOutputs`	String	För logikappar som gör det möjligt för OAuth med Microsoft Entra-ID att auktorisera åtkomst för inkommande anrop till en begäransbaserad utlösarslutpunkt inkluderar du `Authorization` huvudet från OAuth-åtkomsttoken i utlösarens utdata. Mer information finns i Inkludera auktoriseringshuvud i utdata för begärandeutlösare.	Utlösare: Begäran, HTTP-webhook
`Sequential`	String	Kör "för varje" loop-iterationer en i taget, i stället för alla samtidigt parallellt. Det här alternativet fungerar på samma sätt som att ställa in egenskapen på `runtimeConfiguration.concurrency.repetitions` `1`. Du kan ange någon av egenskaperna, men inte båda. Om du vill ange det här alternativet läser du Kör "för varje" loopar sekventiellt.	Åtgärder: Foreach
`SingleInstance`	String	Kör utlösaren för varje logikappinstans sekventiellt och vänta tills den tidigare aktiva körningen har slutförts innan nästa logikappinstans utlöses. Det här alternativet fungerar på samma sätt som att ställa in egenskapen på `runtimeConfiguration.concurrency.runs` `1`. Du kan ange någon av egenskaperna, men inte båda. Information om hur du anger det här alternativet finns i Utlösarinstanser sekventiellt.	Alla utlösare
`SuppressWorkflowHeaders`	String	Skicka `x-ms-*` inte metadatahuvuden i utgående begäranden. Som standard innehåller Azure Logic Apps extra metadatahuvuden med prefixet `x-ms-` i rubriknamnet som en del av utgående begäranden. Vissa äldre tjänster accepterar dock inte begäranden med extra okända huvuden, vilket resulterar i misslyckade begäranden.	Åtgärder: HTTP, Funktion, APIManagement
`SuppressWorkflowHeadersOnResponse`	String	Skicka `x-ms-*` inte metadatahuvuden som svar på inkommande utlösarbegäranden. Som standard skickar Azure Logic Apps svar på inkommande begäranden som innehåller extra metadatahuvuden med prefixet `x-ms-` i rubriknamnet. Vissa äldre tjänster accepterar dock inte begäranden eller svar med extra okända huvuden, vilket resulterar i misslyckade begäranden.	Utlösare: Begäran, HTTP-webhook

Ändra samtidighet för utlösare

När du aktiverar utlösarens samtidighetskontroll körs utlösarinstanser parallellt upp till standardgränsen. Om du vill ändra den här standardgränsen för samtidighet kan du använda antingen kodvisningsredigeraren eller arbetsflödesdesignern eftersom du ändrar samtidighetsinställningen via designern lägger till eller uppdaterar runtimeConfiguration.concurrency.runs egenskapen i den underliggande utlösardefinitionen och vice versa. Den här egenskapen styr det maximala antalet nya arbetsflödesinstanser som kan köras parallellt.

Innan du aktiverar samtidighet för en utlösare bör du läsa följande överväganden:

Du kan inte inaktivera samtidighet när du har aktiverat samtidighetskontrollen.
Om det maximala antalet samtidiga utlösarkörningar når den maximala graden av parallellitet kan efterföljande utlösarkörningar uppleva begränsningar eller felen "429 – För många begäranden". Om du konfigurerar en återförsöksprincip som hanterar 429-fel kan utlösaren uppleva en cykel med återförsök och begränsningsbeteende som orsakar långa fördröjningar i bearbetningen av nya utlösarbegäranden.
När samtidighet är aktiverat minskas gränsen för SplitOn avsevärt för diskbatching-matriser. Om antalet objekt överskrider den här gränsen inaktiveras Funktionen SplitOn.
När samtidighet är aktiverat kan en långvarig logikappinstans orsaka att nya logikappinstanser anger ett väntetillstånd. Det här tillståndet hindrar Azure Logic Apps från att skapa nya instanser och sker även när antalet samtidiga körningar är mindre än det angivna maximala antalet samtidiga körningar.
- Om du vill avbryta det här tillståndet avbryter du de tidigaste instanser som fortfarande körs.
  1. På logikappens meny väljer du Översikt.
  2. I avsnittet Körningshistorik väljer du den tidigaste instansen som fortfarande körs, till exempel:
    
    Dricks
    
    Om du bara vill visa instanser som fortfarande körs öppnar du listan Alla och väljer Kör.
  3. Under Logikappskörning väljer du Avbryt körning.
- Du kan kringgå den här möjligheten genom att lägga till en tidsgräns för alla åtgärder som kan innehålla dessa körningar. Om du arbetar i kodredigeraren kan du läsa Ändra asynkron varaktighet. Annars följer du dessa steg om du använder designern:
  1. I arbetsflödet för logikappen väljer du den åtgärd där du vill lägga till en tidsgräns. I åtgärdens övre högra hörn väljer du knappen ellipser (...) och väljer sedan Inställningar.
  2. Under Timeout anger du tidsgränsen i ISO 8601-format.
Om du vill köra logikappen sekventiellt anger du utlösarens samtidighet till 1 antingen med hjälp av kodvisningsredigeraren eller designern. Kontrollera att du inte också anger utlösarens egenskap till SingleInstance i kodvisningsredigerarenoperationOptions. Annars får du ett verifieringsfel. Mer information finns i Utlösa instanser sekventiellt.

Redigera i kodvyn

I den underliggande utlösardefinitionen runtimeConfiguration.concurrency.runs lägger du till egenskapen och anger värdet baserat på gränserna för samtidighet för utlösaren. Om du vill köra arbetsflödet sekventiellt anger du egenskapsvärdet till 1.

Det här exemplet begränsar samtidiga körningar till 10 instanser:

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

Mer information finns i Konfigurationsinställningar för Körning.

Redigera i arbetsflödesdesignern

I utlösarens övre högra hörn väljer du knappen ellipser (...) och väljer sedan Inställningar.
Under Samtidighetskontroll anger du Gräns till På.
Dra skjutreglaget Grad av parallellitet till önskat värde. Om du vill köra logikappen sekventiellt drar du skjutreglagevärdet till 1.

Ändra samtidighet för varje

Som standard körs "för varje" loop-iterationer samtidigt (samtidigt eller parallellt). Det här beteendet innebär att varje iteration börjar köras innan den tidigare iterationen har slutförts. Antalet iterationer som körs samtidigt har dock en standardgräns. När antalet iterationer som körs samtidigt når den här gränsen måste alla andra iterationer vänta tills de körs.

Om du vill ändra standardgränsen kan du använda antingen kodvisningsredigeraren eller arbetsflödesdesignern eftersom en ändring av samtidighetsinställningen via designern lägger till eller uppdaterar runtimeConfiguration.concurrency.repetitions egenskapen i den underliggande åtgärdsdefinitionen "för varje" och vice versa. Den här egenskapen styr det maximala antalet iterationer som kan köras parallellt.

Kommentar

Om du anger att åtgärden "för varje" ska köras sekventiellt, antingen med hjälp av designern eller kodvisningsredigeraren, ska du inte ange åtgärdens egenskap till Sequential i kodvisningsredigerarenoperationOptions. Annars får du ett verifieringsfel. Mer information finns i Kör "för varje" loopar sekventiellt.

Redigera i kodvyn

I den underliggande definitionen "för varje" lägger du till eller uppdaterar runtimeConfiguration.concurrency.repetitions egenskapen, som kan ha ett värde som sträcker sig från 1 och 50.

Här är ett exempel som begränsar samtidiga körningar till 10 iterationer:

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

Mer information finns i Konfigurationsinställningar för Körning.

Redigera i arbetsflödesdesignern

I åtgärden For each (För varje) i det övre högra hörnet väljer du knappen ellipser (...) och väljer sedan Inställningar.
Under Samtidighetskontroll anger du Samtidighetskontroll till På.
Dra skjutreglaget Grad av parallellitet till önskat värde. Om du vill köra logikappen sekventiellt drar du skjutreglagevärdet till 1.

Ändra gränsen för väntande körningar

Som standard körs logikappens arbetsflödesinstanser samtidigt (samtidigt eller parallellt). Det här beteendet innebär att varje utlösarinstans utlöses innan den tidigare aktiva arbetsflödesinstansen har slutförts. Det finns dock en standardgräns för antalet arbetsflödesinstanser som körs samtidigt. När antalet samtidiga körningar når den här gränsen måste alla andra nya arbetsflödesinstanser vänta tills de körs. Det finns också en standardgräns för antalet väntande arbetsflödesinstanser. När antalet väntande instanser når den här gränsen accepterar Azure Logic Apps inte längre nya arbetsflödesinstanser som ska köras. Begärande- och webhooksutlösare returnerar 429 – För många begärandefel och återkommande utlösare börjar hoppa över avsökningsförsök.

Du kan ändra standardgränsen för samtidighet för utlösare samt standardgränsen för väntande körningar. Den här ändringen saktar dock främst ner utlösaren för att minska trycket på grund av samtidighet. Om du till exempel har avsökningsutlösare och kön för väntande körningar är full på grund av pågående körningar stoppar Azure Logic Apps avsökningen. Om arbetsflödet använder en begäransbaserad utlösare och kön för väntande körningar är full börjar Azure Logic Apps returnera 429-felet. Vissa scenarier finns där Azure Logic Apps inte kan stoppa utlösaren från avsökning utan att införa fel och väljer att lägga till sådana körningar i kön för väntande körningar ändå utan att misslyckas med de anropande körningarna.

I den underliggande utlösardefinitionen runtimeConfiguration.concurrency.maximumWaitingRuns lägger du till egenskapen, som kan ha ett värde som sträcker sig från 1 till 100.

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

Mer information finns i Konfigurationsinställningar för Körning.

Utlösa instanser sekventiellt

Om du bara vill köra varje logikappsarbetsflödesinstans när den tidigare instansen har körts ställer du in att utlösaren ska köras sekventiellt. Du kan använda antingen kodvisningsredigeraren eller arbetsflödesdesignern eftersom en ändring av samtidighetsinställningen via designern också lägger till eller uppdaterar runtimeConfiguration.concurrency.runs egenskapen i den underliggande utlösardefinitionen och vice versa.

Kommentar

När du anger att en utlösare ska köras sekventiellt med hjälp av designern eller kodvisningsredigeraren ska du inte ange utlösarens egenskap till Sequential i kodvisningsredigerarenoperationOptions. Annars får du ett verifieringsfel.

Redigera i kodvyn

I utlösardefinitionen anger du någon av dessa egenskaper, men inte båda.

Ange egenskapen runtimeConfiguration.concurrency.runs till 1:

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

-Eller-

Ange egenskapen operationOptions till SingleInstance:

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

Mer information finns i Konfigurationsinställningar för Körning och Åtgärdsalternativ.

Redigera i arbetsflödesdesignern

I utlösarens övre högra hörn väljer du knappen ellipser (...) och väljer sedan Inställningar.
Under Samtidighetskontroll anger du Gräns till På.
Dra skjutreglaget Grad av parallellitet till talet 1.

Kör "för varje" loopar sekventiellt

Om du vill köra en "för varje" loop-iteration först när den tidigare iterationen har körts ställer du in åtgärden "för varje" så att den körs sekventiellt. Du kan använda antingen kodvisningsredigeraren eller arbetsflödesdesignern eftersom ändringar av åtgärdens samtidighet via designern också lägger till eller uppdaterar runtimeConfiguration.concurrency.repetitions egenskapen i den underliggande åtgärdsdefinitionen och vice versa.

Kommentar

När du ställer in en "för varje"-åtgärd som ska köras sekventiellt, antingen med hjälp av designern eller kodvisningsredigeraren, ska du inte ange åtgärdens egenskap till Sequential i kodvisningsredigerarenoperationOptions. Annars får du ett verifieringsfel.

Redigera i kodvyn

I åtgärdsdefinitionen anger du någon av dessa egenskaper, men inte båda.

Ange egenskapen runtimeConfiguration.concurrency.repetitions till 1:

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

-Eller-

Ange egenskapen operationOptions till Sequential:

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

Mer information finns i Konfigurationsinställningar för Körning och Åtgärdsalternativ.

Redigera i arbetsflödesdesignern

I det övre högra hörnet för varje åtgärd väljer du knappen ellipser (...) och väljer sedan Inställningar.
Under Samtidighetskontroll anger du Samtidighetskontroll till På.
Dra skjutreglaget Grad av parallellitet till talet 1.

Köra åtgärder i ett synkront åtgärdsmönster

Som standard följer HTTP-åtgärden och API Anslut ionsåtgärderna i Azure Logic Apps standardmönstret för asynkron åtgärd, medan åtgärden Svar följer det synkrona åtgärdsmönstret. Det asynkrona mönstret anger att mottagaren omedelbart returnerar svaret "202 ACCEPTED" efter en åtgärd som anropar eller skickar en begäran till den angivna slutpunkten, tjänsten, systemet eller API:et. Den här koden bekräftar att mottagaren accepterade begäran men inte har slutfört bearbetningen. Svaret kan innehålla en location rubrik som anger URL:en och ett uppdaterings-ID som anroparen kan använda för att kontinuerligt avsöka eller kontrollera statusen för den asynkrona begäran tills mottagaren slutar bearbeta och returnerar ett "200 OK" -svar eller annat icke-202-svar. Mer information finns i Asynkron mikrotjänstintegrering framtvingar mikrotjänstautonomi.

I Logikappdesignern har HTTP-åtgärden, API Anslut ion-åtgärderna och svarsåtgärden inställningen Asynkront mönster. När den här inställningen är aktiverad anger den att anroparen inte väntar på att bearbetningen ska slutföras och kan gå vidare till nästa åtgärd, men fortsätter att kontrollera statusen tills bearbetningen stoppas. Om den här inställningen är inaktiverad anger den att anroparen väntar på att bearbetningen ska slutföras innan nästa åtgärd går vidare. Följ dessa steg för att hitta den här inställningen:
1. I HTTP-åtgärdens namnlist väljer du knappen ellipser (...) som öppnar åtgärdens inställningar.
2. Hitta inställningen Asynkront mönster .
I åtgärdens underliggande JSON-definition (JavaScript Object Notation) följer HTTP-åtgärden och API Anslut ionsåtgärderna implicit det asynkrona åtgärdsmönstret.

I vissa scenarier kanske du vill att en åtgärd ska följa det synkrona mönstret i stället. När du till exempel använder HTTP-åtgärden kanske du vill:

I dessa fall kan du göra så att en åtgärd körs synkront med hjälp av följande alternativ:

Ersätt avsökningsversionen av åtgärden med en webhook-version, om den är tillgänglig.
Inaktivera åtgärdens asynkrona beteende genom att följa något av alternativen:
- I Logikappdesignern inaktiverar du inställningen Asynkront mönster.
- Lägg till åtgärdsalternativet "DisableAsyncPattern"i åtgärdens underliggande JSON-definition.

Inaktivera inställning för asynkront mönster

I logikappdesignern går du till åtgärdens namnlist och väljer knappen ellipser (...) som öppnar åtgärdens inställningar.
Leta upp inställningen Asynkront mönster , ändra inställningen till Av om den är aktiverad och välj Klar.

Inaktivera asynkront mönster i åtgärdens JSON-definition

I åtgärdens underliggande JSON-definition lägger du till och anger egenskapen "operationOptions" till under åtgärdens "inputs" avsnitt, till "DisableAsyncPattern" exempel:

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

Autentisera utlösare och åtgärder

HTTP- och HTTPS-slutpunkter stöder olika typer av autentisering. Baserat på den utlösare eller åtgärd som du använder för att göra utgående anrop eller begäranden om åtkomst till dessa slutpunkter kan du välja mellan olika autentiseringstyper. Mer information finns i Lägga till autentisering i utgående anrop.

Nästa steg

Läs mer om arbetsflödesdefinitionsspråk

Dela via

Schemareferensguide för utlösar- och åtgärdstyper i Azure Logic Apps

Översikt över utlösare

Lista över utlösartyper

Inbyggda utlösare

Hanterade API-utlösare

Utlösare – detaljerad referens

API Anslut ionsutlösare

Api Anslut ionWebhook-utlösare

HTTP-utlösare

HTTPWebhook-utlösare

Återkomstutlösare

Utlösare för begäran

Utlösande villkor

Utlösa flera körningar på en matris

Åtgärdsöversikt

Lista över åtgärdstyper

Inbyggda åtgärder

Hanterade API-åtgärder

Kontrollera arbetsflödesåtgärder

Åtgärder – detaljerad referens

API Anslut ion-åtgärd

API Anslut ionWebhook-åtgärd

Skapa åtgärd

Köra JavaScript Code-åtgärd

Funktionsåtgärd

HTTP-åtgärd

Åtgärden anslut

Parsa JSON-åtgärd

Frågeåtgärd

Response action

Välj åtgärd

Tabellåtgärd

Avsluta åtgärd

Vänta-åtgärd

Arbetsflödesåtgärd

Kontrollera arbetsflödesåtgärdsinformation

Foreach-åtgärd

Om åtgärden

Hur villkor använder uttryck

Omfångsåtgärd

Växelåtgärd

Tills åtgärden har åtgärd

Webhooks och prenumerationer

Ändra asynkron varaktighet

Konfigurationsinställningar för körning

Åtgärdsalternativ

Ändra samtidighet för utlösare

Redigera i kodvyn

Redigera i arbetsflödesdesignern

Ändra samtidighet för varje

Redigera i kodvyn

Redigera i arbetsflödesdesignern

Ändra gränsen för väntande körningar

Utlösa instanser sekventiellt

Redigera i kodvyn

Redigera i arbetsflödesdesignern

Kör "för varje" loopar sekventiellt

Redigera i kodvyn

Redigera i arbetsflödesdesignern

Köra åtgärder i ett synkront åtgärdsmönster

Inaktivera inställning för asynkront mönster

Inaktivera asynkront mönster i åtgärdens JSON-definition

Autentisera utlösare och åtgärder

Nästa steg

Feedback

Ytterligare resurser