Sémahivatkozási útmutató eseményindítókhoz és művelettípusokhoz az Azure Logic Appsben

Ez a hivatkozás ismerteti a logikai alkalmazás mögöttes munkafolyamat-definíciójában az eseményindítók és műveletek azonosítására használt általános típusokat, amelyeket a munkafolyamat-definíció nyelve ismertet és érvényesít. A logikai alkalmazásokban használható összekötő-eseményindítók és -műveletek megkereséséhez tekintse meg az Összekötők áttekintésében található listát.

Triggerek áttekintése

Minden munkafolyamat tartalmaz egy eseményindítót, amely meghatározza a munkafolyamat példányosítását és elindítását. Íme az általános eseményindító-kategóriák:

Lekérdezési eseményindító, amely rendszeres időközönként ellenőrzi a szolgáltatás végpontját
Leküldéses eseményindító, amely létrehoz egy előfizetést egy végponthoz, és egy visszahívási URL-címet biztosít, hogy a végpont értesítést küldjön az eseményindítónak a megadott esemény bekövetkezésekor vagy az adatok rendelkezésre állnak. Az eseményindító ezután megvárja a végpont válaszát az indítás előtt.

Az eseményindítók az alábbi legfelső szintű elemeket tartalmaznak, de néhány nem kötelező:

"<trigger-name>": {
   "type": "<trigger-type>",
   "inputs": { "<trigger-inputs>" },
   "recurrence": { 
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>
   },
   "conditions": [ "<array-with-conditions>" ],
   "runtimeConfiguration": { "<runtime-config-options>" },
   "splitOn": "<splitOn-expression>",
   "operationOptions": "<operation-option>"
},

Required

Value	Típus	Description
< eseményindító neve>	String	Az eseményindító neve
< eseményindító típusa>	String	Az eseményindító típusa, például "Http" vagy "ApiConnection"
< trigger-bemenetek>	JSON-objektum	Az eseményindító viselkedését meghatározó bemenetek
< időegység>	String	Az időegység, amely leírja, milyen gyakran aktiválódik a ravasz: "Másodperc", "Perc", "Óra", "Nap", "Hét", "Hónap"
< időegységek száma>	Integer	Egy érték, amely meghatározza, hogy az eseményindító milyen gyakran aktiválódik a gyakoriság alapján, azaz hány időegységet kell várni, amíg az eseményindító újra aktiválódik A minimális és maximális időközök a következők: - Hónap: 1-16 hónap - Nap: 1-500 nap - Óra: 1-12 000 óra - Perc: 1-72 000 perc - Másodperc: 1-9 999 999 másodperc Ha például az intervallum 6, és a gyakoriság "Hónap", az ismétlődés 6 havonta történik.

Optional

Value	Típus	Description
< tömb feltételekkel>	Array	Olyan tömb, amely egy vagy több feltételt tartalmaz, amelyek meghatározzák, hogy futtatni kívánja-e a munkafolyamatot. Csak triggerekhez érhető el.
< runtime-config-options>	JSON-objektum	Az eseményindító futásidejű viselkedését a tulajdonságok beállításával `runtimeConfiguration` módosíthatja. További információ: Futtatókörnyezet konfigurációs beállításai.
< splitOn-expression>	String	Tömböt visszaadó eseményindítók esetén megadhat egy kifejezést, amely a tömbelemeket több munkafolyamat-példányra osztja vagy bontja feldolgozásra.
< operation-option>	String	A tulajdonság beállításával módosíthatja az alapértelmezett viselkedést `operationOptions` . További információ: Művelet beállításai.

Triggertípusok listája

Minden eseményindító-típus más felülettel és bemenetekkel rendelkezik, amelyek meghatározzák az eseményindító viselkedését.

Beépített triggerek

Trigger típusa	Description
HTTP	Bármely végpontot ellenőriz vagy kérdez le . Ennek a végpontnak meg kell felelnie egy adott eseményindító szerződésnek, akár úgy, hogy `202` aszinkron mintát használ, vagy pedig egy tömböt ad vissza.
HTTPWebhook	Létrehoz egy hívható végpontot a logikai alkalmazáshoz, de meghívja a megadott URL-címet a regisztrációhoz vagy a regisztráció törléséhez.
Recurrence	Meghatározott ütemezés alapján indít. Megadhatja az eseményindító indításának jövőbeli dátumát és időpontját. A gyakoriság alapján megadhatja a munkafolyamat futtatásának idejét és napjait is.
Request	Meghívható végpontot hoz létre a logikai alkalmazáshoz, és "manuális" eseményindítóként is ismert. Lásd például a HTTP-végpontokkal rendelkező munkafolyamatok hívását, aktiválását vagy beágyazásának lépéseit.

Felügyelt API-eseményindítók

Trigger típusa	Description
ApiConnection	Egy végpontot a Microsoft által felügyelt API-k vagy "összekötők" használatával ellenőriz vagy kérdez le.
ApiConnectionWebhook	Meghívható végpontot hoz létre a logikai alkalmazás munkafolyamatához a Microsoft által felügyelt API-k vagy "összekötők" meghívásával, hogy feliratkozzanak és leiratkozzanak.

Triggerek – Részletes referencia

APIConnection-eseményindító

Ez az eseményindító a Microsoft által felügyelt API-k vagy "összekötők" használatával ellenőrzi vagy kérdezi le a végpontot, így az eseményindító paraméterei a végponttól függően eltérhetnek. Az eseményindító definíciójának számos szakasza nem kötelező. Az eseményindító viselkedése attól függ, hogy vannak-e szakaszok.

"<APIConnection_trigger_name>": {
   "type": "ApiConnection",
   "inputs": {
      "host": {
         "connection": {
            "name": "@parameters('$connections')['<connection-name>']['connectionId']"
         }
      },
      "method": "<method-type>",
      "path": "/<api-operation>",
      "retryPolicy": { "<retry-behavior>" },
      "queries": { "<query-parameters>" }
   },
   "recurrence": { 
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>
   },
   "runtimeConfiguration": {
      "concurrency": {
         "runs": <max-runs>,
         "maximumWaitingRuns": <max-runs-queue>
      }
   },
   "splitOn": "<splitOn-expression>",
   "operationOptions": "<operation-option>"
}

Required

Property	Value	Típus	Description
None	< APIConnection_trigger_name>	String	Az eseményindító neve
host.connection.name	< kapcsolat neve>	String	A munkafolyamat által használt felügyelt API-kapcsolat neve
method	< metódustípus>	String	A http-metódus a felügyelt API-val való kommunikációhoz: GET, PUT, POST, PATCH, DELETE
path	< api-operation>	String	A meghívandó API-művelet
recurrence.frequency	< időegység>	String	Az eseményindító aktiválásának gyakoriságát leíró időegység: Másodperc, Perc, Óra, Nap, Hét, Hónap
recurrence.interval	< időegységek száma>	Integer	Egy érték, amely meghatározza, hogy az eseményindító milyen gyakran aktiválódik a gyakoriság alapján, azaz hány időegységet kell várni, amíg az eseményindító újra aktiválódik A minimális és maximális időközök a következők: - Hónap: 1-16 hónap Nap: 1-től 500 napig - Óra: 1-12 000 óra - Perc: 1-72 000 perc - Második: 1-9 999,999 másodperc Ha például az intervallum 6, és a gyakoriság hónap, az ismétlődés 6 havonta történik.

Optional

Property	Value	Típus	Description
retryPolicy	< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
queries	< lekérdezési paraméterek>	JSON-objektum	Az API-hívással felvenni kívánt lekérdezési paraméterek. Az objektum például `"queries": { "api-version": "2018-01-01" }` hozzáadja a `?api-version=2018-01-01` a híváshoz.
runtimeConfiguration.concurrency.runs	< maximális futtatások>	Integer	Alapértelmezés szerint a munkafolyamat-példányok egyidejűleg (egyidejűleg vagy párhuzamosan) futnak az alapértelmezett korlátig. Ha módosítani szeretné ezt a korlátot egy új <darabszámérték> beállításával, olvassa el az eseményindító egyidejűségének módosítása című témakört.
runtimeConfiguration.maximumWaitingRuns	< max-runs-queue>	Integer	Ha a munkafolyamat már a példányok maximális számát futtatja, az új futtatások az alapértelmezett korlátig kerülnek ebbe az üzenetsorba. Az alapértelmezett korlát módosításáról a várakozási futtatások korlátjának módosítása című témakörben olvashat. A példányok maximális számának módosításához adja meg a runtimeConfiguration.concurrency.run tulajdonság értékét. Megjegyzés: Ha a
splitOn	< splitOn-expression>	String	Tömböket visszaadó triggereket adó esetén ez a kifejezés a használni kívánt tömbre hivatkozik, így minden tömbelemhez létrehozhat és futtathat munkafolyamat-példányt, nem pedig "mindegyikhez" hurkot. Ez a kifejezés például az eseményindító törzstartalman belül visszaadott tömb egy elemét jelöli: `@triggerbody()?['value']`
operationOptions	< operation-option>	String	A tulajdonság beállításával módosíthatja az alapértelmezett viselkedést `operationOptions` . További információ: Művelet beállításai.

Outputs

Element	Típus	Description
headers	JSON-objektum	A válasz fejlécei
body	JSON-objektum	A válasz szövege
állapotkód	Integer	A válasz állapotkódja

Example

Ez az eseményindító-definíció minden nap ellenőrzi az e-maileket egy munkahelyi vagy iskolai fiók Beérkezett üzenetek mappájában:

"When_a_new_email_arrives": {
   "type": "ApiConnection",
   "inputs": {
      "host": {
         "connection": {
            "name": "@parameters('$connections')['office365']['connectionId']"
         }
      },
      "method": "get",
      "path": "/Mail/OnNewEmail",
      "queries": {
          "fetchOnlyWithAttachment": false,
          "folderPath": "Inbox",
          "importance": "Any",
          "includeAttachments": false
      }
   },
   "recurrence": {
      "frequency": "Day",
      "interval": 1
   }
}

ApiConnectionWebhook eseményindító

Ez az eseményindító egy Microsoft által felügyelt API használatával küld egy előfizetési kérelmet egy végpontnak, egy visszahívási URL-címet biztosít, ahová a végpont választ küldhet, és megvárja, amíg a végpont válaszol. További információ: Végpont-előfizetések.

"<ApiConnectionWebhook_trigger_name>": {
   "type": "ApiConnectionWebhook",
   "inputs": {
      "body": {
          "NotificationUrl": "@{listCallbackUrl()}"
      },
      "host": {
         "connection": {
            "name": "@parameters('$connections')['<connection-name>']['connectionId']"
         }
      },
      "retryPolicy": { "<retry-behavior>" },
      "queries": "<query-parameters>"
   },
   "runTimeConfiguration": {
      "concurrency": {
         "runs": <max-runs>,
         "maximumWaitingRuns": <max-run-queue>
      }
   },
   "splitOn": "<splitOn-expression>",
   "operationOptions": "<operation-option>"
}

Required

Value	Típus	Description
< kapcsolat neve>	String	A munkafolyamat által használt felügyelt API-kapcsolat neve
< törzs-tartalom>	JSON-objektum	A felügyelt API-nak hasznos adatként küldendő üzenettartalmak

Optional

Value	Típus	Description
< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
< lekérdezési paraméterek>	JSON-objektum	Az API-hívással felvenni kívánt lekérdezési paraméterek Az objektum például `"queries": { "api-version": "2018-01-01" }` hozzáadja a `?api-version=2018-01-01` a híváshoz.
< maximális futtatások>	Integer	Alapértelmezés szerint a munkafolyamat-példányok egyidejűleg (egyidejűleg vagy párhuzamosan) futnak az alapértelmezett korlátig. Ha módosítani szeretné ezt a korlátot egy új <darabszámérték> beállításával, olvassa el az eseményindító egyidejűségének módosítása című témakört.
< max-runs-queue>	Integer	Ha a munkafolyamat már futtatja a példányok maximális számát, amelyet a `runtimeConfiguration.concurrency.runs` tulajdonság alapján módosíthat, az új futtatások az alapértelmezett korlátig kerülnek ebbe az üzenetsorba. Az alapértelmezett korlát módosításáról a várakozási futtatások korlátjának módosítása című témakörben olvashat.
< splitOn-expression>	String	Tömböket visszaadó triggereket adó esetén ez a kifejezés a használni kívánt tömbre hivatkozik, így minden tömbelemhez létrehozhat és futtathat munkafolyamat-példányt, nem pedig "mindegyikhez" hurkot. Ez a kifejezés például az eseményindító törzstartalman belül visszaadott tömb egy elemét jelöli: `@triggerbody()?['value']`
< operation-option>	String	A tulajdonság beállításával módosíthatja az alapértelmezett viselkedést `operationOptions` . További információ: Művelet beállításai.

Example

Ez az eseményindító-definíció előfizet az Office 365 Outlook API-ra, visszahívási URL-címet biztosít az API-végpontnak, és megvárja, amíg a végpont válaszol egy új e-mail érkezésekor.

"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-eseményindító

Ez az eseményindító kérést küld a megadott HTTP- vagy HTTPS-végpontnak a megadott ismétlődési ütemezés alapján. Az eseményindító ezután ellenőrzi a választ annak megállapításához, hogy a munkafolyamat fut-e. További információ: Szolgáltatásvégpontok hívása HTTP-en vagy HTTPS-en keresztül az Azure Logic Appsből.

"HTTP": {
   "type": "Http",
   "inputs": {
      "method": "<method-type>",
      "uri": "<HTTP-or-HTTPS-endpoint-URL>",
      "headers": { "<header-content>" },
      "queries": "<query-parameters>",
      "body": "<body-content>",
      "authentication": { "<authentication-type-and-property-values>" },
      "retryPolicy": {
         "type": "<retry-behavior>"
      }
   },
   "recurrence": {
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>
   },
   "runtimeConfiguration": {
      "concurrency": {
         "runs": <max-runs>,
         "maximumWaitingRuns": <max-runs-queue>
      }
   },
   "operationOptions": "<operation-option>"
}

Required

Property	Value	Típus	Description
`method`	< metódustípus>	String	A kimenő kérés küldéséhez használt módszer: "GET", "PUT", "POST", "PATCH" vagy "DELETE"
`uri`	< HTTP-or-HTTPS-endpoint-URL>	String	A HTTP- vagy HTTPS-végpont URL-címe, ahová a kimenő kérelmet el szeretné küldeni. Maximális sztringméret: 2 KB Egy Azure-szolgáltatás vagy erőforrás esetében ez az URI-szintaxis tartalmazza az erőforrás-azonosítót és a elérni kívánt erőforrás elérési útját.
`frequency`	< időegység>	String	Az időegység, amely leírja, milyen gyakran aktiválódik a ravasz: "Másodperc", "Perc", "Óra", "Nap", "Hét", "Hónap"
`interval`	< időegységek száma>	Integer	Egy érték, amely meghatározza, hogy az eseményindító milyen gyakran aktiválódik a gyakoriság alapján, azaz hány időegységet kell várni, amíg az eseményindító újra aktiválódik A minimális és maximális időközök a következők: - Hónap: 1-16 hónap - Nap: 1-500 nap - Óra: 1-12 000 óra - Perc: 1-72 000 perc - Másodperc: 1-9 999 999 másodperc Ha például az intervallum 6, és a gyakoriság "Hónap", az ismétlődés 6 havonta történik.

Optional

Property	Value	Típus	Description
`headers`	< fejléc-tartalom>	JSON-objektum	A kéréshez mellékelendő fejlécek Például a nyelv és a típus beállításához: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
`queries`	< lekérdezési paraméterek>	JSON-objektum	A kérelemben használni kívánt lekérdezési paraméterek Az `"queries": { "api-version": "2018-01-01" }` objektum például hozzáadja a `?api-version=2018-01-01` a kéréshez.
`body`	< törzs-tartalom>	JSON-objektum	A kérelem részeként elküldendő üzenet tartalma
`authentication`	< hitelesítési-típus- és tulajdonságértékek>	JSON-objektum	A kimenő kérések hitelesítéséhez használt hitelesítési modell. További információ: Hitelesítés hozzáadása kimenő hívásokhoz. A Scheduleren túl a `authority` tulajdonság támogatott. Ha nincs megadva, az alapértelmezett érték az `https://management.azure.com/`, de más értéket is használhat.
`retryPolicy` > `type`	< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
`runs`	< maximális futtatások>	Integer	Alapértelmezés szerint a munkafolyamat-példányok egyidejűleg (egyidejűleg vagy párhuzamosan) futnak az alapértelmezett korlátig. Ha módosítani szeretné ezt a korlátot egy új <darabszámérték> beállításával, olvassa el az eseményindító egyidejűségének módosítása című témakört.
`maximumWaitingRuns`	< max-runs-queue>	Integer	Ha a munkafolyamat már futtatja a példányok maximális számát, amelyet a `runtimeConfiguration.concurrency.runs` tulajdonság alapján módosíthat, az új futtatások az alapértelmezett korlátig kerülnek ebbe az üzenetsorba. Az alapértelmezett korlát módosításáról a várakozási futtatások korlátjának módosítása című témakörben olvashat.
`operationOptions`	< operation-option>	String	A tulajdonság beállításával módosíthatja az alapértelmezett viselkedést `operationOptions` . További információ: Művelet beállításai.

Outputs

Element	Típus	Description
`headers`	JSON-objektum	A válasz fejlécei
`body`	JSON-objektum	A válasz szövege
`status code`	Integer	A válasz állapotkódja

A bejövő kérelmekre vonatkozó követelmények

A logikai alkalmazás megfelelő működéséhez a végpontnak meg kell felelnie egy adott eseményindító-mintának vagy szerződésnek, és fel kell ismernie a következő választulajdonságokat:

Property	Required	Description
Állapotkód	Yes	Az "200 OK" állapotkód futtatásba kezd. Más állapotkódok nem indítják el a futtatásokat.
Élőfej újrapróbálkozás után	No	Másodpercek száma, amíg a logikai alkalmazás újra le nem kérdezi a végpontot
Hely fejléce	No	A következő lekérdezési időközön meghívandó URL-cím. Ha nincs megadva, a rendszer az eredeti URL-címet használja.

Példa a különböző kérések viselkedésére

Állapotkód	Újrapróbálkozás után	Behavior
200	{none}	Futtassa a munkafolyamatot, majd a megadott ismétlődés után ellenőrizze újra a további adatokat.
200	10 másodperc	Futtassa a munkafolyamatot, majd 10 másodperc után ellenőrizze újra a további adatokat.
202	60 másodperc	Ne indítsa el a munkafolyamatot. A következő kísérlet egy percen belül megtörténik, a megadott ismétlődés függvényében. Ha a megadott ismétlődés kevesebb, mint egy perc, az újrapróbálkozás utáni fejléc elsőbbséget élvez. Ellenkező esetben a rendszer a megadott ismétlődéseket használja.
400	{none}	Kérési hiba, ne indítsa el a munkamenetet. Ha nincs `retryPolicy` definiálva, akkor a rendszer az alapértelmezett házirendet használja. Miután elérte az újrapróbálkozási próbálkozások számát, az eseményindító ismét ellenőrzi az adatokat a megadott ismétlődés után.
500	{none}	Kiszolgálóhiba, ne futtassa a munkafolyamatot. Ha nincs `retryPolicy` definiálva, akkor a rendszer az alapértelmezett házirendet használja. Miután elérte az újrapróbálkozási próbálkozások számát, az eseményindító ismét ellenőrzi az adatokat a megadott ismétlődés után.

HTTPWebhook-eseményindító

Ez az eseményindító meghívhatóvá teszi a logikai alkalmazást egy olyan végpont létrehozásával, amely regisztrálhat egy előfizetést a megadott végpont URL-címének meghívásával. Amikor létrehozza ezt az eseményindítót a munkafolyamatban, egy kimenő kérés kezdeményezi az előfizetés regisztrálását. Így az eseményindító elkezdheti figyelni az eseményeket. Ha egy művelet érvénytelensé teszi ezt az eseményindítót, a kimenő kérés automatikusan megszakítja az előfizetést. További információ: Végpont-előfizetések.

A HTTPWebhook-eseményindítókaszinkron korlátait is megadhatja. Az eseményindító viselkedése a használt vagy kihagyott szakaszoktól függ.

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

Egyes értékek, például <a metódus típusa>, mind az "subscribe""unsubscribe" objektumokhoz elérhetők.

Required

Value	Típus	Description
< metódustípus>	String	Az előfizetési kérelem http-metódusa: "GET", "PUT", "POST", "PATCH" vagy "DELETE"
< endpoint-subscribe-URL>	String	A végpont URL-címe, ahová el szeretné küldeni az előfizetési kérelmet

Optional

Value	Típus	Description
< metódustípus>	String	A lemondási kérelemhez használt HTTP-metódus: "GET", "PUT", "POST", "PATCH" vagy "DELETE"
< endpoint-unsubscribe-URL>	String	A végpont URL-címe, ahová el szeretné küldeni a lemondási kérelmet
< törzs-tartalom>	String	Az előfizetésben vagy a lemondási kérelemben elküldendő üzenettartalmak
< hitelesítés típusa>	JSON-objektum	A kimenő kérések hitelesítéséhez használt hitelesítési modell. További információ: Hitelesítés hozzáadása kimenő hívásokhoz.
< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
< maximális futtatások>	Integer	Alapértelmezés szerint a munkafolyamat-példányok mindegyike egyszerre (egyidejűleg vagy párhuzamosan) fut az alapértelmezett korlátig. Ha módosítani szeretné ezt a korlátot egy új <darabszámérték> beállításával, olvassa el az eseményindító egyidejűségének módosítása című témakört.
< max-runs-queue>	Integer	Ha a munkafolyamat már futtatja a példányok maximális számát, amelyet a `runtimeConfiguration.concurrency.runs` tulajdonság alapján módosíthat, az új futtatások az alapértelmezett korlátig kerülnek ebbe az üzenetsorba. Az alapértelmezett korlát módosításáról a várakozási futtatások korlátjának módosítása című témakörben olvashat.
< operation-option>	String	A tulajdonság beállításával módosíthatja az alapértelmezett viselkedést `operationOptions` . További információ: Művelet beállításai.

Outputs

Element	Típus	Description
headers	JSON-objektum	A válasz fejlécei
body	JSON-objektum	A válasz szövege
állapotkód	Integer	A válasz állapotkódja

Example

Ez az eseményindító létrehoz egy előfizetést a megadott végpontra, egyedi visszahívási URL-címet biztosít, és megvárja az újonnan közzétett technológiai cikkeket.

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

Ismétlődési eseményindító

Ez az eseményindító a megadott ismétlődési ütemezés alapján fut, és könnyen létrehozhat egy rendszeresen futó munkafolyamatot.

"Recurrence": {
   "type": "Recurrence",
   "recurrence": {
      "frequency": "<time-unit>",
      "interval": <number-of-time-units>,
      "startTime": "<start-date-time-with-format-YYYY-MM-DDThh:mm:ss>",
      "timeZone": "<time-zone>",
      "schedule": {
         // Applies only when frequency is Day or Week. Separate values with commas.
         "hours": [ <one-or-more-hour-marks> ], 
         // Applies only when frequency is Day or Week. Separate values with commas.
         "minutes": [ <one-or-more-minute-marks> ], 
         // Applies only when frequency is Week. Separate values with commas.
         "weekDays": [ "Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday" ] 
      }
   },
   "runtimeConfiguration": {
      "concurrency": {
         "runs": <max-runs>,
         "maximumWaitingRuns": <max-runs-queue>
      }
   },
   "operationOptions": "<operation-option>"
}

Required

Value	Típus	Description
< időegység>	String	Az időegység, amely leírja, milyen gyakran aktiválódik a ravasz: "Másodperc", "Perc", "Óra", "Nap", "Hét", "Hónap"
< időegységek száma>	Integer	Egy érték, amely meghatározza, hogy az eseményindító milyen gyakran aktiválódik a gyakoriság alapján, azaz hány időegységet kell várni, amíg az eseményindító újra aktiválódik A minimális és maximális időközök a következők: - Hónap: 1-16 hónap - Nap: 1-500 nap - Óra: 1-12 000 óra - Perc: 1-72 000 perc - Másodperc: 1-9 999 999 másodperc Ha például az intervallum 6, és a gyakoriság "Hónap", az ismétlődés 6 havonta történik.

Optional

Value	Típus	Description
< start-date-time-with-format-YYYY-MM-DDThh:mm:ss>	String	A kezdő dátum és időpont ebben a formátumban: YYYY-MM-DDThh:mm:ss, ha időzónát ad meg -or- YYYY-MM-DDThh:mm:ssZ, ha nem ad meg időzónát Így például ha 2017. szeptember 18-án 14:00-kor szeretné használni, adja meg a "2017-09-18T14:00:00" értéket, és adjon meg egy időzónát, például "Csendes-óceáni téli idő", vagy adja meg a "2017-09-18T14:00:00Z" értéket időzóna nélkül. Megjegyzés: Ez a kezdési idő legfeljebb 49 év lehet a jövőben, és az ISO 8601 dátumidő specifikációját kell követnie UTC dátum időformátumban, de UTC-eltolás nélkül. Ha nem ad meg időzónát, szóköz nélkül kell hozzáadnia a "Z" betűt a végén. Ez a "Z" az egyenértékű tengeri időre utal. Az egyszerű ütemezések esetében a kezdési időpont az első előfordulás, míg összetett ütemezések esetén az eseményindító nem aktiválódik hamarabb, mint a kezdési időpont. A kezdési dátumokkal és időpontokkal kapcsolatos további információkért tekintse meg a rendszeresen futó tevékenységek létrehozását és ütemezését ismertető témakört.
< időzóna>	String	Csak akkor érvényes, ha megadja a kezdési időpontot, mert ez az eseményindító nem fogadja el az UTC-eltolást. Adja meg az alkalmazni kívánt időzónát.
< egy vagy több órás jelek>	Egész vagy egész szám tömb	Ha a "Nap" vagy a "Hét" `frequency`értéket adja meg, megadhat egy vagy több egész számot 0-tól 23-ig, vesszővel elválasztva, a munkafolyamat futtatásának napjaként. Ha például a "10", a "12" és a "14" értéket adja meg, akkor órajelként 10 óra, 12 óra és 14 óra lesz.
< egy vagy több perces jelek>	Egész vagy egész szám tömb	Ha a "Nap" vagy a "Hét" `frequency`értéket adja meg, megadhat egy vagy több egész számot 0 és 59 között, vesszővel elválasztva, a munkafolyamat futtatásakor az óra perceiként. Megadhatja például a "30" értéket a percjelként, és az előző példát használva a nap óráira 10:30, 12:30 és 14:30 óra lesz.
weekDays	Sztring vagy sztringtömb	Ha a "Hét" `frequency`értéket adja meg, megadhat egy vagy több napot vesszővel elválasztva, amikor futtatni szeretné a munkafolyamatot: "Hétfő", "Kedd", "Szerda", "Csütörtök", "Péntek", "Szombat" és "Vasárnap"
< maximális futtatások>	Integer	Alapértelmezés szerint a munkafolyamat-példányok mindegyike egyszerre (egyidejűleg vagy párhuzamosan) fut az alapértelmezett korlátig. Ha módosítani szeretné ezt a korlátot egy új <darabszámérték> beállításával, olvassa el az eseményindító egyidejűségének módosítása című témakört.
< max-runs-queue>	Integer	Ha a munkafolyamat már futtatja a példányok maximális számát, amelyet a `runtimeConfiguration.concurrency.runs` tulajdonság alapján módosíthat, az új futtatások az alapértelmezett korlátig kerülnek ebbe az üzenetsorba. Az alapértelmezett korlát módosításáról a várakozási futtatások korlátjának módosítása című témakörben olvashat.
< operation-option>	String	A tulajdonság beállításával módosíthatja az alapértelmezett viselkedést `operationOptions` . További információ: Művelet beállításai.

1. példa

Ez az alapvető ismétlődési eseményindító naponta fut:

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

2. példa

Megadhatja az eseményindító indításának kezdő dátumát és időpontját. Ez az ismétlődési eseményindító a megadott napon kezdődik, majd naponta aktiválódik:

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

3. példa

Ez az ismétlődési eseményindító 2017. szeptember 9-én 14:00-kor kezdődik, és minden hétfőn 10:30-kor, 12:30-kor és 14:30-kor aktiválódik a Csendes-óceáni téli idő szerint:

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

Az eseményindítóra vonatkozó további információkért és példákért lásd a rendszeres futó tevékenységek létrehozását és ütemezését.

Kérelem eseményindítója

Ez az eseményindító meghívhatóvá teszi a logikai alkalmazást egy olyan végpont létrehozásával, amely képes fogadni a bejövő kéréseket. Ehhez az eseményindítóhoz adjon meg egy JSON-sémát, amely leírja és ellenőrzi az eseményindító által a bejövő kérelemből kapott hasznos adatokat vagy bemeneteket. A séma megkönnyíti a triggertulajdonságok hivatkozását a munkafolyamat későbbi műveleteiből is.

Note

A Kérés eseményindító eredeti neve manuális volt, amely bizonyos helyeken továbbra is megjelenhet. Ez a név úgy módosult, hogy nagyobb konzisztenciát hozzon létre az eseményindítóval létrehozott munkafolyamat-minta körül.

Az eseményindító meghívásához a listCallbackUrlMunkafolyamat-szolgáltatás REST API-jában leírt API-t kell használnia. Az eseményindító HTTP-végpontként való használatáról a HTTP-végpontokkal rendelkező hívások, eseményindítók és beágyazott munkafolyamatok című témakörben olvashat.

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

Required

Value	Típus	Description
< tulajdonság-név>	String	A JSON-séma egyik tulajdonságának neve, amely a payload tartalmát írja le
< tulajdonságtípus>	String	A tulajdonság típusa

Optional

Value	Típus	Description
< metódustípus>	String	Az a metódus, amelyet a bejövő kéréseknek használniuk kell a logikai alkalmazásod meghívásához: "GET", "PUT", "POST", "PATCH", "DELETE"
< relative-path-for-accepted-parameter>	String	Annak a paraméternek a relatív elérési útja, amelyet a végpont URL-címe elfogadhat
< kötelező tulajdonságok>	Array	Egy vagy több olyan tulajdonság, amely értékeket igényel
< maximális futtatások>	Integer	Alapértelmezés szerint a munkafolyamat-példányok mindegyike egyszerre (egyidejűleg vagy párhuzamosan) fut az alapértelmezett korlátig. Ha módosítani szeretné ezt a korlátot egy új <darabszámérték> beállításával, olvassa el az eseményindító egyidejűségének módosítása című témakört.
< max-runs-queue>	Integer	Ha a munkafolyamat már futtatja a példányok maximális számát, amelyet a `runtimeConfiguration.concurrency.runs` tulajdonság alapján módosíthat, az új futtatások az alapértelmezett korlátig kerülnek ebbe az üzenetsorba. Az alapértelmezett korlát módosításáról a várakozási futtatások korlátjának módosítása című témakörben olvashat.
< operation-option>	String	A tulajdonság beállításával módosíthatja az alapértelmezett viselkedést `operationOptions` . További információ: Művelet beállításai.

Example

Ez az eseményindító azt határozza meg, hogy egy bejövő kérésnek a HTTP POST metódussal kell meghívnia az eseményindítót, és tartalmaznia kell egy sémát, amely ellenőrzi a bejövő kérés bemenetét:

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

Triggerfeltételek

Bármely eseményindítóhoz, és kizárólag eseményindítókhoz beilleszthet egy tömböt, amely egy vagy több kifejezést tartalmaz olyan feltételekhez, amelyek meghatározzák, hogy a munkafolyamat fut-e. Ha hozzá szeretné adni a conditions tulajdonságot egy eseményindítóhoz a munkafolyamatban, nyissa meg a logikai alkalmazást a kódnézet-szerkesztőben.

Megadhatja például, hogy egy eseményindító csak akkor aktiválódik, ha egy webhely belső kiszolgálóhibát ad vissza, ha hivatkozik az eseményindító állapotkódjára a conditions tulajdonságban:

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

Alapértelmezés szerint az eseményindító csak a "200 OK" válasz lekérése után aktiválódik. Amikor egy kifejezés egy eseményindító állapotkódjára hivatkozik, a rendszer lecseréli az eseményindító alapértelmezett viselkedését. Ha tehát azt szeretné, hogy az eseményindító egynél több állapotkódra , például a "200" és a "201" állapotkódra aktiváljon, feltételként ezt a kifejezést kell megadnia:

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

Több munkafolyamat-futtatás aktiválása tömbön

Olyan helyzetekben, amikor a munkafolyamat tömböket fogadó eseményindítót használ feldolgozásra, előfordulhat, hogy az Egyes ciklusok használata túl sokáig tart. A feldolgozás felgyorsítása érdekében az egyik lehetőség a párhuzamos ágak létrehozása. Ha az eseményindító támogatja a feloldást, az eseményindító feloszthatja a tömbelemeket, és futtathat egy külön munkafolyamat-példányt minden tömbelemhez. Ez a beállítás például akkor hasznos, ha olyan végpontot szeretne lekérdezni, amely több új elemet is visszaadhat a lekérdezési időközök között.

Ezt a képességet csak azok az eseményindítók támogatják, amelyek képesek tömböket fogadni és visszaadni a tömböket, például a Kérés, a HTTP, az Azure Service Bus vagy az Office Outlook 365. Ezeknél az eseményindítóknál a munkafolyamat-tervezőben bekapcsolhatja a Felosztás beállítást, amely hozzáadja a splitOn tulajdonságot az eseményindító definícióhoz.

Note

Ha az eseményindító Swagger-fájlja egy tömb hasznos adatát írja le, a splitOn tulajdonság automatikusan hozzáadódik az eseményindító definíciójához. Ha nem, és az eseményindító képes tömböket fogadni, hozzáadhatja a tulajdonságot a válasz hasznos adataihoz, amely tartalmazza a feloldani kívánt tömböt.

A hibaeltérési funkció használata előtt tekintse át a következő szempontokat:

Ha az eseményindító egyidejűsége is be van kapcsolva, a felosztási korlát jelentősen csökken. Ha az elemek száma meghaladja ezt a korlátot, a Felosztás funkció nem érhető el.
A Felosztás funkció nem működik a szinkron válaszmintával. Ha egy munkafolyamat a Válasz műveletet használja, és bekapcsolja a Felosztás beállítást, aszinkron módon fut, és azonnal választ küld 202 ACCEPTED .
A felosztott tömbelemek száma korlátot tartalmaz egyetlen munkafolyamat-futtatás során. További információ: Hurkolási és kötegelési korlátok.
Ha a tulajdonság használatával állítja be a hibaelhárítást az splitOn eseményindító-definíción keresztül, a tömbön kívüli tulajdonságokra közvetlenül nem hivatkozhat vagy nem férhet hozzá. A hibák elkerülése érdekében előzze meg a referenciát az ? operátorral. Példák: A debatching bekapcsolása az eseményindító definíciójában.

A debatching bekapcsolása a tervezőn keresztül

Kövesse az alábbi lépéseket a munkafolyamat-tervezőben a hibaeltérés beállításához egy olyan eseményindítón, ahol támogatott:

Nyissa meg a logikai alkalmazás erőforrását az [Azure Portalon].
Nyissa meg a munkafolyamatot a tervezőben.
A tervezőben válassza ki azt az eseményindítót, amely támogatja a törlést az eseményindító információs paneljének megnyitásához.
A Beállítások lap Általános csoportjában keresse meg a Felosztás beállítást, és ha nincs bekapcsolva, módosítsa a beállítást Be állásra.

A debatching bekapcsolása az eseményindító definíciójában

Egyes triggerek tömböket kezelnek, de a Felosztás beállítás nem érhető el a tervezőn keresztül. Az ilyen eseményindítók esetében kövesse az alábbi lépéseket a splitOn tulajdonság triggerdefinícióban való hozzáadásához:

Tegyük fel például, hogy a munkafolyamat a HTTP-eseményindítóval hívja meg az API-t, és a következő választ kapja:

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

Ha a munkafolyamatnak csak a Rows tömbből származó tartalomra van szüksége, hozzáadhatja és beállíthatja a splitOn tulajdonságot az eseményindító definíciójában az alábbi példában látható módon:

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

Note

Ne feledje, hogy ha a tulajdonságot splitOn használja, nem férhet hozzá közvetlenül a tömbön kívül található tulajdonságokhoz vagy referenciatulajdonságokhoz. A hibák elkerülése érdekében használja az ? operátort a példákban látható módon.

A munkafolyamat-definíció a tulajdonság értékeit splitOn is használhatja @triggerBody().name és name lekérheti. Ezek az értékek "customer-name-one" az első munkafolyamat-futtatásból és "customer-name-two" a második munkafolyamat-futtatásból származnak. Ebben a példában az eseményindító kimenetei a következő értékekhez hasonlóan néznek ki:

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

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

Műveletek áttekintése

Az Azure Logic Apps különböző művelettípusokat biztosít – mindegyik különböző bemenetekkel rendelkezik, amelyek meghatározzák a művelet egyedi viselkedését. A műveletek magas szintű elemeket tartalmaznak, de néhány nem kötelező:

"<action-name>": {
   "type": "<action-type>",
   "inputs": { 
      "<input-name>": { "<input-value>" },
      "retryPolicy": "<retry-behavior>" 
   },
   "runAfter": { "<previous-trigger-or-action-status>" },
   "runtimeConfiguration": { "<runtime-config-options>" },
   "operationOptions": "<operation-option>"
},

Required

Value	Típus	Description
< művelet neve>	String	A művelet neve
< művelettípus>	String	A művelet típusa, például "Http" vagy "ApiConnection"
< bemeneti név>	String	A művelet viselkedését meghatározó bemenet neve
< bemeneti érték>	Various	A bemeneti érték, amely lehet sztring, egész szám, JSON-objektum stb.
< previous-trigger-or-action-status>	JSON-objektum	Az eseményindító vagy művelet neve és eredményül kapott állapota, amelynek közvetlenül az aktuális művelet futtatása előtt kell futnia

Optional

Value	Típus	Description
< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
< runtime-config-options>	JSON-objektum	Egyes műveletek esetében a tulajdonságok beállításával `runtimeConfiguration` módosíthatja a művelet futásidejű viselkedését. További információ: Futtatókörnyezet konfigurációs beállításai.
< operation-option>	String	Egyes műveleteknél módosíthatja az alapértelmezett viselkedést a `operationOptions` tulajdonság beállításával. További információ: Művelet beállításai.

Művelettípusok listája

Íme néhány gyakran használt művelettípus:

Beépített művelettípusok , például az alábbi példák és egyebek:
- HTTP http http-en vagy HTTPS-en keresztüli végpontok hívásához
- Válasz kérésekre való válaszadásra
- JavaScript-kód végrehajtása JavaScript-kódrészletek futtatásához
- Függvény az Azure Functions meghívásához
- Adatműveleti műveletek, például Csatlakozás, Összeállítás, Táblázat, Kijelölés és egyéb műveletek, amelyek különböző bemenetekből hoznak létre vagy alakítanak át adatokat
- Egy másik logikai alkalmazás munkafolyamatának meghívására szolgáló munkafolyamat
Olyan felügyelt API-művelettípusok , mint az ApiConnection és az ApiConnectionWebHook , amelyek a Microsoft által felügyelt különböző összekötőket és API-kat hívják meg, például az Azure Service Bust, az Office 365 Outlookot, a Power BI-t, az Azure Blob Storage-t, a OneDrive-ot, a GitHubot stb.
Olyan munkafolyamat-művelettípusok irányítása, mint például az If, az Foreach, az választó szerkezet, az Hatókör és az Until, amelyek más műveleteket tartalmaznak, és segítenek a munkafolyamatok rendszerezett végrehajtásában

Beépített műveletek

Művelettípus	Description
Compose	Egyetlen kimenetet hoz létre bemenetekből, amelyek különböző típusúak lehetnek.
JavaScript-kód végrehajtása	Futtassa a meghatározott feltételeknek megfelelő JavaScript-kódrészleteket. A kódkövetelményekről és további információkról lásd: Kódrészletek hozzáadása és futtatása beágyazott kóddal.
Function	Meghív egy Azure-függvényt.
HTTP	HTTP-végpontot hív meg.
Join	Sztringet hoz létre egy tömb összes eleméből, és elválasztja az elemeket egy megadott elválasztó karakterrel.
JSON elemzése	Felhasználóbarát tokeneket készít a JSON-tartalom tulajdonságaiból. Ezután hivatkozhat ezekre a tulajdonságokra, ha beépíti a tokeneket a logikai alkalmazásába.
Query	Egy feltétel vagy szűrő alapján létrehoz egy tömböt egy másik tömb elemeiből.
Response	Választ hoz létre egy bejövő hívásra vagy kérésre.
Select	JSON-objektumokkal rendelkező tömböt hoz létre egy másik tömb elemeinek a megadott térkép alapján történő átalakításával.
Table	CSV- vagy HTML-táblázatot hoz létre egy tömbből.
Terminate	Leállítja az aktívan futó munkafolyamatot.
Wait	Szünetelteti a munkafolyamatot egy megadott időtartamra vagy a megadott dátumig és időpontig.
Workflow	Munkafolyamatot ágyaz be egy másik munkafolyamatba.

Felügyelt API-műveletek

Művelettípus	Description
ApiConnection	HTTP-végpont meghívása Microsoft által felügyelt API használatával.
ApiConnectionWebhook	A HTTP Webhookhoz hasonlóan működik, de Microsoft által felügyelt API-t használ.

Munkafolyamat-műveletek vezérlése

Ezek a műveletek segítenek szabályozni a munkafolyamat végrehajtását, és más műveleteket is tartalmazhatnak. A vezérlő munkafolyamat-műveleten kívülről közvetlenül hivatkozhat a munkafolyamat-műveleten belüli műveletekre. Ha például egy hatókörön belül van egy Http művelet, a munkafolyamat bármely pontjáról hivatkozhat a @body('Http') kifejezésre. A vezérlő-munkafolyamat-műveletben található műveletek azonban csak olyan műveletek után "futtathatók", amelyek ugyanabban a vezérlő-munkafolyamat-struktúrában találhatók.

Művelettípus	Description
ForEach	Futtassa ugyanazokat a műveleteket egy ciklusban egy tömb minden eleméhez.
If	Hajtsa végre a műveleteket annak alapján, hogy a megadott feltétel igaz vagy hamis.
Scope	Műveletek futtatása a csoportállapot alapján egy műveletkészletből.
Switch	Olyan esetekre rendezett műveleteket futtathat, amelyekben a kifejezések, objektumok vagy jogkivonatok értékei megegyeznek az egyes esetek által megadott értékekkel.
Until	Futtassa a műveleteket egy ciklusban, amíg a megadott feltétel nem teljesül.

Műveletek – Részletes referencia

APIConnection művelet

Ez a művelet HTTP-kérést küld egy Microsoft által felügyelt API-nak, és az API-val és paraméterekkel kapcsolatos információkat, valamint egy érvényes kapcsolatra mutató hivatkozást igényel.

"<action-name>": {
   "type": "ApiConnection",
   "inputs": {
      "host": {
         "connection": {
            "name": "@parameters('$connections')['<api-name>']['connectionId']"
         },
         "<other-action-specific-input-properties>"        
      },
      "method": "<method-type>",
      "path": "/<api-operation>",
      "retryPolicy": "<retry-behavior>",
      "queries": { "<query-parameters>" },
      "<other-action-specific-properties>"
    },
    "runAfter": {}
}

Required

Value	Típus	Description
< művelet neve>	String	Az összekötő által megadott művelet neve
< api-name>	String	A kapcsolathoz használt Microsoft által felügyelt API neve
< metódustípus>	String	Az API meghívásának HTTP-metódusa: "GET", "PUT", "POST", "PATCH" vagy "DELETE"
< api-operation>	String	A meghívandó API-művelet

Optional

Value	Típus	Description
< egyéb műveletspecifikus-bemeneti tulajdonságok>	JSON-objektum	Az adott műveletre vonatkozó egyéb bemeneti tulajdonságok
< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
< lekérdezési paraméterek>	JSON-objektum	Az API-hívással felvenni kívánt lekérdezési paraméterek. Az objektum például `"queries": { "api-version": "2018-01-01" }` hozzáadja a `?api-version=2018-01-01` a híváshoz.
< egyéb műveletspecifikus tulajdonságok>	JSON-objektum	Az adott műveletre vonatkozó egyéb tulajdonságok

Example

Ez a definíció az Office 365 Outlook-összekötő e-mail küldése műveletét ismerteti, amely egy Microsoft által felügyelt API:

"Send_an_email": {
   "type": "ApiConnection",
   "inputs": {
      "body": {
         "Body": "Thank you for your membership!",
         "Subject": "Hello and welcome!",
         "To": "Sophie.Owen@contoso.com"
      },
      "host": {
         "connection": {
            "name": "@parameters('$connections')['office365']['connectionId']"
         }
      },
      "method": "POST",
      "path": "/Mail"
    },
    "runAfter": {}
}

APIConnectionWebhook művelet

Ez a művelet http-en keresztül küld egy előfizetési kérelmet egy végpontnak egy Microsoft által felügyelt API használatával, egy visszahívási URL-címet biztosít, ahová a végpont választ küldhet, és megvárja, amíg a végpont válaszol. További információ: Végpont-előfizetések.

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

Egyes értékek, például <a metódus típusa>, mind az "subscribe""unsubscribe" objektumokhoz elérhetők.

Required

Value	Típus	Description
< művelet neve>	String	Az összekötő által megadott művelet neve
< metódustípus>	String	A végpontról való feliratkozáshoz vagy leiratkozáshoz használható HTTP-metódus: "GET", "PUT", "POST", "PATCH" vagy "DELETE"
< api-subscribe-URL>	String	Az API-ra való feliratkozáshoz használandó URI

Optional

Value	Típus	Description
< api-unsubscribe-URL>	String	Az API-ról való leiratkozáshoz használandó URI
< fejléc-tartalom>	JSON-objektum	A kéréshez küldött fejlécek Például egy kérés nyelvének és típusának beállításához: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
< törzs-tartalom>	JSON-objektum	A kérésben elküldendő üzenettartalmak
< hitelesítés típusa>	JSON-objektum	A kimenő kérések hitelesítéséhez használt hitelesítési modell. További információ: Hitelesítés hozzáadása kimenő hívásokhoz.
< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
< lekérdezési paraméterek>	JSON-objektum	Az API-hívással felvenni kívánt lekérdezési paraméterek Az objektum például `"queries": { "api-version": "2018-01-01" }` hozzáadja a `?api-version=2018-01-01` a híváshoz.
< egyéb műveletspecifikus-bemeneti tulajdonságok>	JSON-objektum	Az adott műveletre vonatkozó egyéb bemeneti tulajdonságok
< egyéb műveletspecifikus tulajdonságok>	JSON-objektum	Az adott műveletre vonatkozó egyéb tulajdonságok

Az ApiConnectionWebhook-műveletekre vonatkozó korlátokat a HTTP aszinkron korlátaival megegyező módon is megadhatja.

Írási művelet

Ez a művelet egyetlen kimenetet hoz létre több bemenetből, beleértve a kifejezéseket is. A kimenet és a bemenetek bármilyen típusúak lehetnek, amelyeket az Azure Logic Apps natív módon támogat, például tömbök, JSON-objektumok, XML és bináris. Ezután a művelet kimenetét más műveletekben is használhatja.

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

Required

Value	Típus	Description
< inputs-to-compose>	Any	Az egyetlen kimenet létrehozásához szükséges bemenetek

1. példa

Ez a műveletdefiníció összeolvasztja a abcdefg -t egy szóközzel és az 1234 értékkel.

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

A művelet által létrehozott kimenet:

abcdefg 1234

2. példa

Ez a műveletdefiníció egyesít egy sztringváltozót, amely tartalmaz abcdefg és egy egész szám változót, amely a következőket tartalmazza 1234:

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

A művelet által létrehozott kimenet:

"abcdefg1234"

JavaScript Code-művelet végrehajtása

Ez a művelet egy JavaScript-kódrészletet futtat, és egy jogkivonaton keresztül adja vissza az eredményeket, amelyekre a munkafolyamat későbbi műveletei hivatkozhatnak.

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

Required

Value	Típus	Description
< JavaScript-code-snippet>	Varies	A futtatni kívánt JavaScript-kód. A kódkövetelményekről és további információkról lásd: Kódrészletek futtatása munkafolyamatokban. A `code` kódrészlet az attribútumban használhatja a csak olvasható `workflowContext` objektumot bemenetként. Ez az objektum olyan altulajdonságokkal rendelkezik, amelyek hozzáférést biztosítanak a kódnak az eseményindító kimeneteihez és a munkafolyamat korábbi műveleteihez. Az objektumról további információt a `workflowContext`workflowContext objektummal kapcsolatos referencia-eseményindító és műveleteredmények című témakörben talál.

Bizonyos esetekben kötelező

Az explicitDependencies attribútum azt határozza meg, hogy explicit módon fel szeretné venni az eseményindítóból, a korábbi műveletekből vagy mindkettőből származó eredményeket a kódrészlet függőségeiként. További információ a függőségek hozzáadásáról: Függőségek hozzáadása paraméterekként egy beágyazott kódművelethez.

Az includeTrigger attribútumhoz megadhatja a true vagy a false értékeket.

Value	Típus	Description
< előző műveletek>	Sztringtömb	Egy tömb, amelyben a műveletnevek JSON formátumban vannak függőségként. Ügyeljen arra, hogy a munkafolyamat-definícióban megjelenő műveletneveket használja, ahol a műveletnevek aláhúzásjeleket (_), szóközöket (" ") használnak.

1. példa

Ez a művelet olyan kódot futtat, amely lekéri a logikai alkalmazás munkafolyamatának nevét, és ennek eredményeként visszaadja a "Hello world from <logic-app-name>" szöveget. Ebben a példában a kód a munkafolyamat nevét a workflowContext.workflow.name tulajdonsághoz az írásvédett workflowContext objektumon keresztül való hozzáféréssel hivatkozza meg. Az objektum használatával kapcsolatos további információkért lásd: workflowContextReferencia-eseményindító és műveleteredmények a kódban.

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

2. példa

Ez a művelet egy logikai alkalmazás munkafolyamatában futtat kódot, amely akkor aktiválódik, amikor új e-mail érkezik egy Outlook-fiókba. A munkafolyamat az Office 365 Outlook jóváhagyási e-mail-műveletét is használja, amely a kapott e-mail tartalmát és a jóváhagyási kérelmet továbbítja.

A kód kinyeri az e-mail-címeket az e-mail-üzenet Body tulajdonságából, és visszaadja a címeket a SelectedOption jóváhagyási művelet tulajdonságértékével együtt. A művelet kifejezetten tartalmazza a Jóváhagyási e-mail küldése műveletet függőségként az actions objektumon belüli explicitDependencies objektumban.

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

Függvényművelet

Ez a művelet meghív egy korábban létrehozott Azure-függvényt.

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

Required

Value	Típus	Description
< Azure-function-ID>	String	A meghívni kívánt Azure-függvény erőforrás-azonosítója. Az érték formátuma a következő: "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group>/providers/Microsoft.Web/sites/<Azure-function-app-name>/functions/<Azure-function-name>"
< metódustípus>	String	A függvény meghívásához használt HTTP-metódus: "GET", "PUT", "POST", "PATCH" vagy "DELETE" Ha nincs megadva, az alapértelmezett a "POST" metódus.

Optional

Value	Típus	Description
< fejléc-tartalom>	JSON-objektum	Vannak-e bármilyen fejlécek, amiket a hívással kell küldeni Például egy kérés nyelvének és típusának beállításához: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
< törzs-tartalom>	JSON-objektum	A kérésben elküldendő üzenettartalmak
< lekérdezési paraméterek>	JSON-objektum	Az API-hívással felvenni kívánt lekérdezési paraméterek Az objektum például `"queries": { "api-version": "2018-01-01" }` hozzáadja a `?api-version=2018-01-01` a híváshoz.
< egyéb műveletspecifikus-bemeneti tulajdonságok>	JSON-objektum	Az adott műveletre vonatkozó egyéb bemeneti tulajdonságok
< egyéb műveletspecifikus tulajdonságok>	JSON-objektum	Az adott műveletre vonatkozó egyéb tulajdonságok

A logikai alkalmazás mentésekor az Azure Logic Apps az alábbi ellenőrzéseket hajtja végre a hivatkozott függvényen:

A munkafolyamatnak hozzá kell férnie a függvényhez.
A munkafolyamat csak szabványos HTTP-eseményindítót vagy általános JSON-webhook-eseményindítót használhat.

Az Azure Logic Apps lekéri és gyorsítótárazza a futtatókörnyezetben használt eseményindító URL-címét. Ha azonban bármely művelet érvényteleníti a gyorsítótárazott URL-címet, a függvényművelet futásidőben meghiúsul. A probléma megoldásához mentse újra a logikai alkalmazást, hogy a logikai alkalmazás ismét megkapja és gyorsítótárazza az eseményindító URL-címét.
A függvény útvonala nem definiálható.
Csak a "függvény" és a "névtelen" engedélyezési szint engedélyezett.

Example

Ez a műveletdefiníció meghívja a korábban létrehozott "GetProductID" függvényt:

"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-művelet

Ez a művelet kérést küld a megadott HTTP- vagy HTTPS-végpontnak, és ellenőrzi a választ annak megállapításához, hogy a munkafolyamat fut-e. További információ: Szolgáltatásvégpontok hívása HTTP-en vagy HTTPS-en keresztül az Azure Logic Appsből.

"HTTP": {
   "type": "Http",
   "inputs": {
      "method": "<method-type>",
      "uri": "<HTTP-or-HTTPS-endpoint-URL>",
      "headers": { "<header-content>" },
      "queries": { "<query-parameters>" },
      "body": "<body-content>",
      "authentication": { "<authentication-type-and-property-values>" },
      "retryPolicy": {
         "type": "<retry-behavior>"
      },
   },
   "runAfter": {}
}

Required

Property	Value	Típus	Description
`method`	< metódustípus>	String	A kimenő kérés küldéséhez használt módszer: "GET", "PUT", "POST", "PATCH" vagy "DELETE"
`uri`	< HTTP-or-HTTPS-endpoint-URL>	String	A HTTP- vagy HTTPS-végpont URL-címe, ahová a kimenő kérelmet el szeretné küldeni. Maximális sztringméret: 2 KB Egy Azure-szolgáltatás vagy erőforrás esetében ez az URI-szintaxis tartalmazza az erőforrás-azonosítót és a elérni kívánt erőforrás elérési útját.

Optional

Property	Value	Típus	Description
`headers`	< fejléc-tartalom>	JSON-objektum	A kéréshez mellékelendő fejlécek Például a nyelv és a típus beállításához: `"headers": { "Accept-Language": "en-us", "Content-Type": "application/json" }`
`queries`	< lekérdezési paraméterek>	JSON-objektum	A kérelemben használni kívánt lekérdezési paraméterek Az objektum például `"queries": { "api-version": "2018-01-01" }` hozzáadja a `?api-version=2018-01-01` a híváshoz.
`body`	< törzs-tartalom>	JSON-objektum	A kérelem részeként elküldendő üzenet tartalma
`authentication`	< hitelesítési-típus- és tulajdonságértékek>	JSON-objektum	A kimenő kérések hitelesítéséhez használt hitelesítési modell. További információ: Hitelesítés hozzáadása kimenő hívásokhoz. A Scheduleren túl a `authority` tulajdonság támogatott. Ha nincs megadva, az alapértelmezett érték az `https://management.azure.com/`, de más értéket is használhat.
`retryPolicy` > `type`	< újrapróbálkozás>	JSON-objektum	A 408, 429 és 5XX állapotkóddal és kapcsolati kivételekkel rendelkező időszakos hibák újrapróbálkozásának viselkedését testre szabja. További információ: Újrapróbálkozás szabályzatok.
< egyéb műveletspecifikus-bemeneti tulajdonságok>	< bemeneti tulajdonság>	JSON-objektum	Az adott műveletre vonatkozó egyéb bemeneti tulajdonságok
< egyéb műveletspecifikus tulajdonságok>	< tulajdonság-érték>	JSON-objektum	Az adott műveletre vonatkozó egyéb tulajdonságok

Example

Ez a műveletdefiníció úgy kapja meg a legfrissebb híreket, hogy egy kérést küld a megadott végpontnak:

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

Csatlakozás művelet

Ez a művelet létrehoz egy sztringet a tömb összes eleméből, és elválasztja ezeket az elemeket a megadott elválasztó karakterrel.

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

Required

Value	Típus	Description
< tömb>	Array	A forráselemeket biztosító tömb vagy kifejezés. Ha egy kifejezést ad meg, a kifejezést dupla idézőjelekkel foglalja össze.
< elválasztó>	Egy karakterből álló karakterlánc	Az a karakter, amely elválasztja a sztring egyes elemeit

Example

Tegyük fel, hogy van egy korábban létrehozott "myIntegerArray" változó, amely ezt az egész szám tömböt tartalmazza:

[1,2,3,4]

Ez a műveletdefiníció lekéri a változó értékeit egy variables() kifejezés függvényének használatával, és létrehozza ezt a sztringet azokkal az értékekkel, amelyek vesszővel vannak elválasztva: "1,2,3,4"

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

JSON-művelet elemzése

Ez a művelet felhasználóbarát mezőket vagy jogkivonatokat hoz létre a JSON-tartalom tulajdonságaiból. A logikai alkalmazásában ezeket a tulajdonságokat a tokenek használatával érheti el. Ha például JSON-kimenetet szeretne használni olyan szolgáltatásokból, mint az Azure Service Bus és az Azure Cosmos DB, ezt a műveletet belefoglalhatja a logikai alkalmazásba, így könnyebben hivatkozhat a kimenetben lévő adatokra.

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

Required

Value	Típus	Description
< JSON-forrás>	JSON-objektum	Az elemezni kívánt JSON-tartalom
< JSON-séma>	JSON-objektum	Az alapul szolgáló JSON-tartalmat leíró JSON-séma, amelyet a művelet a forrás JSON-tartalom elemzéséhez használ. Tipp: A munkafolyamat-tervezőben megadhatja a sémát, vagy megadhat egy hasznos adatmintát, hogy a művelet létrehozhassa a sémát.

Example

Ez a műveletdefiníció létrehozza ezeket a jogkivonatokat, amelyeket a munkafolyamatban használhat, de csak a JSON-elemzési műveletet követő műveletekben:

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

Ebben a példában a "content" tulajdonság határozza meg az elemezni kívánt művelet JSON-tartalmát. Ezt a JSON-tartalmat is megadhatja minta hasznos adatként a séma létrehozásához.

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

A "séma" tulajdonság a JSON-tartalom leírásához használt JSON-sémát adja meg:

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

Lekérdezési művelet

Ez a művelet egy tömböt hoz létre egy másik tömb elemeiből egy megadott feltétel vagy szűrő alapján.

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

Required

Value	Típus	Description
< tömb>	Array	A forráselemeket biztosító tömb vagy kifejezés. Ha egy kifejezést ad meg, a kifejezést dupla idézőjelekkel foglalja össze.
< feltétel vagy szűrő>	String	A forrástömb elemeinek szűréséhez használt feltétel Megjegyzés: Ha nincs olyan érték, amely megfelel a feltételnek, akkor a művelet létrehoz egy üres tömböt.

Example

Ez a műveletdefiníció létrehoz egy tömböt, amely a megadott értéknél nagyobb értékekkel rendelkezik, ami kettő:

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

Válaszművelet

Ez a művelet létrehozza a HTTP-kérésre adott válasz hasznos adatait.

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

Required

Value	Típus	Description
< response-status-code>	Integer	A bejövő kérésnek küldött HTTP-állapotkód. Az alapértelmezett kód az "200 OK", de a kód bármilyen érvényes állapotkód lehet, amely 2xx, 4xx vagy 5xx értékkel kezdődik, de nem a 3xxx-zel.

Optional

Value	Típus	Description
< válaszfejlécek>	JSON-objektum	Egy vagy több fejléc, amely szerepel a válaszban
< választörzs>	Various	A válasz törzse, amely lehet sztring, JSON-objektum vagy akár bináris tartalom egy korábbi műveletből

Example

Ez a műveletdefiníció választ hoz létre egy HTTP-kérésre a megadott állapotkóddal, üzenettörzsgel és üzenetfejlécekkel:

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

Restrictions

A többi művelettől eltérően a válaszművelet speciális korlátozásokkal rendelkezik:

A munkafolyamat csak akkor használhatja a Válasz műveletet, ha a munkafolyamat EGY HTTP-kérés-eseményindítóval kezdődik, ami azt jelenti, hogy a munkafolyamatot HTTP-kérésnek kell aktiválnia.
A munkafolyamat a Válasz műveletet bárhol használhatja, kivéve a Foreach-hurkokat , az Addig ciklusokat, beleértve a szekvenciális hurkokat és a párhuzamos ágakat.
Az eredeti kérés csak akkor kapja meg a munkafolyamat válaszát, ha a válaszművelethez szükséges összes művelet a HTTP időtúllépési korlátján belül befejeződik.

Ha azonban a munkafolyamat egy másik logikai alkalmazást hív meg beágyazott munkafolyamatként, a szülő munkafolyamat megvárja, amíg a beágyazott munkafolyamat befejeződik, függetlenül attól, hogy mennyi idő telik el a beágyazott munkafolyamat befejeződése előtt.
Amikor a munkafolyamat a Válasz műveletet és a szinkron válaszmintát használja, a munkafolyamat nem használhatja a splitOn parancsot az eseményindító definíciójában, mert ez a parancs több futtatásból áll. Ellenőrizze ezt az esetet, amikor a PUT metódust használják, és ha igaz, adjon vissza egy "érvénytelen kérés" választ.

Ellenkező esetben, ha a munkafolyamat a splitOn parancsot és a Válasz műveletet használja, a munkafolyamat aszinkron módon fut, és azonnal "202 ACCEPTED" választ ad vissza.
Amikor a munkafolyamat végrehajtása eléri a Válasz műveletet, de a bejövő kérés már kapott választ, a válaszművelet "Sikertelen" állapotúként lesz megjelölve az ütközés miatt. Ennek eredményeképpen a logikai alkalmazás futtatása "Sikertelen" állapottal is meg van jelölve.

Művelet kiválasztása

Ez a művelet JSON-objektumokat tartalmazó tömböt hoz létre egy másik tömb elemeinek a megadott térkép alapján történő átalakításával. A kimeneti tömb és a forrástömb mindig ugyanannyi elemből áll. Bár a kimeneti tömbben nem módosíthatja az objektumok számát, hozzáadhatja vagy eltávolíthatja a tulajdonságokat és azok értékeit ezeken az objektumokon. A select tulajdonság legalább egy kulcs-érték párt határoz meg, amely meghatározza a forrástömb elemeinek átalakítására vonatkozó leképezést. A kulcs-érték párok egy tulajdonságot és annak értékét jelölik a kimeneti tömb összes objektumában.

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

Required

Value	Típus	Description
< tömb>	Array	A forráselemeket biztosító tömb vagy kifejezés. Győződjön meg arról, hogy egy kifejezést idézőjelekbe foglal. Megjegyzés: Ha a forrástömb üres, a művelet létrehoz egy üres tömböt.
< kulcsnév>	String	A < eredményéhez rendelt tulajdonságnév> Ha új tulajdonságot szeretne hozzáadni a kimeneti tömb összes objektumához, adja meg < a tulajdonság kulcsnevét> és < a tulajdonságérték kifejezését>. Ha el szeretne távolítani egy tulajdonságot a tömb összes objektumából, hagyja ki a < tulajdonság kulcsnevét>.
< kifejezés>	String	Az a kifejezés, amely átalakítja az elemet a forrástömbben, és az eredményt < rendeli>

A Kiválasztás művelet kimenetként létrehoz egy tömböt, így a kimenetet használni kívánt műveleteknek vagy el kell fogadniuk egy tömböt, vagy a tömböt a fogyasztói művelet által elfogadott típussá kell konvertálnia. Ha például a kimeneti tömböt sztringgé szeretné konvertálni, átadhatja a tömböt a Compose műveletnek, majd hivatkozhat a többi művelet Compose műveletének kimenetére.

Example

Ez a műveletdefiníció létrehoz egy JSON-objektumtömböt egy egész számtömbből. A művelet végigfut a forrástömbön, lekéri az egyes egész számokat a @item() kifejezés használatával, és minden egyes JSON-objektum "number" tulajdonságához rendeli az egyes értékeket:

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

A művelet által létrehozott tömb:

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

Ha ezt a tömbkimenetet más műveletekben szeretné használni, adja át ezt a kimenetet egy Compose műveletnek:

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

Ezután használhatja a Compose művelet kimenetét a többi műveletben, például az Office 365 Outlook – E-mail küldése műveletben:

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

Táblaművelet

Ez a művelet csv- vagy HTML-táblát hoz létre egy tömbből. JSON-objektumokkal rendelkező tömbök esetén ez a művelet automatikusan létrehozza az oszlopfejléceket az objektumok tulajdonságnevéből. Más adattípusú tömbök esetén meg kell adnia az oszlopfejléceket és az értékeket. Ez a tömb például tartalmazza az "ID" és a "Product_Name" tulajdonságokat, amelyeket ez a művelet az oszlopfejlécek neveihez használhat:

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

"Create_<CSV | HTML>_table": {
   "type": "Table",
   "inputs": {
      "format": "<CSV | HTML>",
      "from": <array>,
      "columns": [ 
         {
            "header": "<column-name>",
            "value": "<column-value>"
         },
         {
            "header": "<column-name>",
            "value": "<column-value>"
         } 
      ]
   },
   "runAfter": {}
}

Required

Value	Típus	Description
<CSV vagy HTML>	String	A létrehozni kívánt táblázat formátuma
< tömb>	Array	A táblázat forráselemeit biztosító tömb vagy kifejezés Megjegyzés: Ha a forrástömb üres, a művelet létrehoz egy üres táblát.

Optional

Az oszlopfejlécek és -értékek megadásához vagy testreszabásához használja a tömböt columns . Ha header-value a párok fejlécének neve megegyezik, az értékük ugyanabban az oszlopban jelenik meg az adott fejlécnév alatt. Ellenkező esetben minden egyedi fejléc egyedi oszlopot határoz meg.

Value	Típus	Description
< oszlopnév>	String	Az egy oszlop fejlécének neve
< oszlop-érték>	Any	Az oszlopban lévő érték

1. példa

Tegyük fel, hogy rendelkezik egy korábban létrehozott "myItemArray" változóval, amely jelenleg a tömböt tartalmazza:

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

Ez a műveletdefiníció létrehoz egy CSV-táblát a "myItemArray" változóból. A from tulajdonság által használt kifejezés a "myItemArray" tömböt a variables() függvény használatával lekéri.

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

A művelet által létrehozott CSV-tábla:

ID,Product_Name 
0,Apples 
1,Oranges

2. példa

Ez a műveletdefiníció létrehoz egy HTML-táblát a "myItemArray" változóból. A from tulajdonság által használt kifejezés a "myItemArray" tömböt a variables() függvény használatával lekéri.

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

A művelet által létrehozott HTML-táblázat:

azonosító	Product_Name
0	Apples
1	Oranges

3. példa

Ez a műveletdefiníció létrehoz egy HTML-táblát a "myItemArray" változóból. Ez a példa azonban felülírja az alapértelmezett oszlopfejlécneveket a "Stock_ID" és a "Leírás" értékekkel, és hozzáadja az "Organikus" szót a "Leírás" oszlop értékeihez.

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

A művelet által létrehozott HTML-táblázat:

Stock_ID	Description
0	Bio alma
1	Organikus narancs

Művelet leállítható

Ez a művelet leállítja a munkafolyamat-példány futtatását, megszakítja a folyamatban lévő műveleteket, kihagyja a fennmaradó műveleteket, és visszaadja a megadott állapotot. Használhatja például a Leállítás műveletet, ha a logikai alkalmazásnak teljesen ki kell lépnie egy hibaállapotból. Ez a művelet nem befolyásolja a már végrehajtott műveleteket, és nem jelenik meg a Foreach és az Until ciklusokban, beleértve a szekvenciális hurkokat is.

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

Required

Value	Típus	Description
< állapot>	String	A futtatáshoz visszatérendő állapot: "Sikertelen", "Megszakítva", vagy "Sikeres"

Optional

A "runError" objektum tulajdonságai csak akkor érvényesek, ha a "runStatus" tulajdonság "Sikertelen" állapotra van állítva.

Value	Típus	Description
< hibakód vagy név>	String	A hiba kódja vagy neve
< hibaüzenet>	String	A hibát leíró üzenet vagy szöveg, valamint az alkalmazásfelhasználó által végrehajtható műveletek

Example

Ez a műveletdefiníció leállítja a munkafolyamat futtatását, a futtatás állapotát "Sikertelen" értékre állítja, és visszaadja az állapotot, egy hibakódot és egy hibaüzenetet:

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

Várakozási művelet

Ez a művelet szünetelteti a munkafolyamat végrehajtását a megadott időközönként vagy a megadott időpontig, de mindkettőt nem.

Megadott időköz

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

Megadott idő

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

Required

Value	Típus	Description
< egységek száma>	Integer	A Késleltetés műveletnél a várakozni kívánt egységek száma
< intervallum>	String	A Késleltetés műveletnél a várakozási időköz: "Second", "Minute", "Hour", "Day", "Week", "Month"
< dátum-időbélyeg>	String	A Késleltetési idő műveletnél a végrehajtás folytatásának dátuma és ideje. Ennek az értéknek az UTC dátum időformátumát kell használnia.

1. példa

Ez a műveletdefiníció 15 percig szünetelteti a munkafolyamatot:

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

2. példa

Ez a műveletdefiníció a megadott időpontig szünetelteti a munkafolyamatot:

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

Munkafolyamat-művelet

Ez a művelet meghív egy másik korábban létrehozott logikai alkalmazást, ami azt jelenti, hogy más logikaialkalmazás-munkafolyamatokat is felvehet és újra felhasználhat. A gyermek- vagy beágyazott logikai alkalmazás kimeneteit a beágyazott logikai alkalmazást követő műveletekben is használhatja, feltéve, hogy a gyermeklogika-alkalmazás választ ad vissza.

Az Azure Logic Apps ellenőrzi a meghívni kívánt eseményindítóhoz való hozzáférést, ezért győződjön meg arról, hogy hozzáfér az eseményindítóhoz. Emellett a beágyazott logikai alkalmazásnak meg kell felelnie az alábbi feltételeknek:

Az eseményindító meghívhatóvá teszi a beágyazott logikai alkalmazást, például a kérést vagy a HTTP-eseményindítót
Ugyanaz az Azure-előfizetés, mint a szülő logikai alkalmazásod.
A beágyazott logikai alkalmazás kimeneteinek a szülő logikai alkalmazásban való használatához a beágyazott logikai alkalmazásnak válaszművelettel kell rendelkeznie

"<nested-logic-app-name>": {
   "type": "Workflow",
   "inputs": {
      "body": { "<body-content" },
      "headers": { "<header-content>" },
      "host": {
         "triggerName": "<trigger-name>",
         "workflow": {
            "id": "/subscriptions/<Azure-subscription-ID>/resourceGroups/<Azure-resource-group>/providers/Microsoft.Logic/<nested-logic-app-name>"
         }
      }
   },
   "runAfter": {}
}

Required

Value	Típus	Description
< beágyazott-logic-app-name>	String	A meghívni kívánt logikai alkalmazás neve
< eseményindító neve>	String	A meghívni kívánt beágyazott logikai alkalmazás eseményindítójának neve
< Azure-subscription-ID>	String	A beágyazott logikai alkalmazás Azure-előfizetés-azonosítója
< Azure-erőforráscsoport>	String	A beágyazott logikai alkalmazás Azure-erőforráscsoportjának neve

Optional

Value	Típus	Description
< fejléc-tartalom>	JSON-objektum	Bármilyen fejlécek a hívással küldendők
< törzs-tartalom>	JSON-objektum	A hívással küldendő üzenettartalmak

Outputs

A művelet kimenetei a beágyazott logikai alkalmazás Válasz műveletétől függően változnak. Ha a beágyazott logikai alkalmazás nem tartalmaz válaszműveletet, a kimenetek üresek.

Example

Miután a "Start_search" művelet sikeresen befejeződött, ez a munkafolyamat-műveletdefiníció meghív egy másik , "Get_product_information" nevű logikai alkalmazást, amely a megadott bemeneteken halad át:

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

Munkafolyamat-művelet részleteinek szabályozása

Foreach művelet

Ez az ismétlődő művelet végighalad egy tömbön, és minden tömbelemen műveleteket hajt végre. Alapértelmezés szerint a "for each" ciklus párhuzamosan fut legfeljebb a megadott maximális számú ciklusig. Ehhez a maximális értékhez tekintse meg a korlátokat és a konfigurációt. Ismerje meg hogyan hozhat létre "for each" hurkot.

"For_each": {
   "type": "Foreach",
   "actions": { 
      "<action-1>": { "<action-definition-1>" },
      "<action-2>": { "<action-definition-2>" }
   },
   "foreach": "<for-each-expression>",
   "runAfter": {},
   "runtimeConfiguration": {
      "concurrency": {
         "repetitions": <count>
      }
    },
    "operationOptions": "<operation-option>"
}

Required

Value	Típus	Description
< action-1... n>	String	Az egyes tömbelemeken futó műveletek neve
< action-definition-1... n>	JSON-objektum	A futtatott műveletek definíciói
< for-each-expression>	String	Az a kifejezés, amely a megadott tömb minden elemére hivatkozik

Optional

Value	Típus	Description
< darabszám>	Integer	Alapértelmezés szerint a "minden" ciklus iterációja egyszerre (egyidejűleg vagy párhuzamosan) fut az alapértelmezett korlátig. Ha módosítani szeretné ezt a korlátot egy új <darabszámérték> beállításával, olvassa el az "egyes" ciklusok egyidejűségének módosítása című témakört.
< operation-option>	String	Ha az "egyes" ciklusokat egymás után szeretné futtatni, és nem párhuzamosan, állítsa a <műveletbeállítást>`Sequential` vagy <a számlálást>`1`, de mindkettőt nem. További információért lásd: for-each ciklusok sorban futtatása.

Example

Ez a "minden" ciklus egy e-mailt küld a tömb minden eleméhez, amely egy bejövő e-mail mellékleteit tartalmazza. A hurok e-mailt küld, amely tartalmazza a mellékletet, egy személynek, aki áttekinti a mellékletet.

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

Ha csak az eseményindító kimeneteként átadott tömböt szeretné megadni, ez a kifejezés lekéri a <tömbnév> tömböt az eseményindító törzséből. Ha a tömb nem létezik, a hiba elkerülése érdekében a kifejezés az operátort ? használja:

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

Ha a művelet

Ez a művelet, amely egy feltételes utasítás, kiértékel egy feltételt képviselő kifejezést, és egy másik ágat futtat attól függően, hogy a feltétel igaz vagy hamis. Ha a feltétel igaz, a feltétel "Sikeres" állapottal van megjelölve. Megtudhatja, hogyan hozhat létre feltételes utasításokat.

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

Value	Típus	Description
< feltétel>	JSON-objektum	Az értékelendő feltétel, amely lehet kifejezés
< action-1>	JSON-objektum	Az a művelet, amely akkor fut, ha <a feltétel> értéke igaz
< műveletdefiníció>	JSON-objektum	A művelet definíciója
< action-2>	JSON-objektum	Az a művelet, amely akkor fut, ha <a feltétel> értéke hamis

A actions vagy else objektumokban végzett műveletek a következő állapotokat kapják:

"Sikeres" a futtatás és a sikeresség esetén
"Sikertelen," amikor fut és meghiúsul
"Kihagyva", ha az érintett ág nem fut

Example

Ez a feltétel azt határozza meg, hogy ha az egész szám változó értéke nullánál nagyobb, a munkafolyamat ellenőrzi a webhelyet. Ha a változó nulla vagy kevesebb, a munkafolyamat egy másik webhelyet ellenőriz.

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

Kifejezések használata a feltételekben

Íme néhány példa a kifejezések feltételekben való használatára:

JSON	Result
"kifejezés": "@parameters('<hasSpecialAction>')"	Csak logikai kifejezések esetén a feltétel minden olyan értékre teljesül, amely igaz értéket ad vissza. Ha más típusokat logikai értékre szeretne konvertálni, használja az alábbi függvényeket: `empty()` vagy `equals()`.
"kifejezés": "@greater(actions('<'>).output.value, parameters('<'>))"	Összehasonlító függvények esetén a művelet csak akkor fut, ha a < kimenete > meghaladja a <küszöbértéket>.
"kifejezés": "@or(greater(actions('<'>).output.value, parameters('<'>)), less(actions('<same-action>').output.value, 100))"	Logikai függvények és beágyazott logikai kifejezések létrehozása esetén a művelet akkor fut, ha a < kimenete > meghaladja a <küszöbértéket> vagy 100 alatt van.
"kifejezés": "@equals(length(actions('<'>).outputs.errors), 0)"	A tömbfüggvények segítségével ellenőrizheti, hogy a tömb tartalmaz-e elemeket. A művelet akkor fut, ha a `errors` tömb üres.

Hatókörművelet

Ez a művelet logikailag hatókörökbe csoportosítja a műveleteket, amelyek a hatókör műveleteinek futtatása után saját állapotot kapnak. Ezután a hatókör állapotával meghatározhatja, hogy futnak-e más műveletek. Megtudhatja, hogyan hozhat létre hatóköröket.

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

Required

Value	Típus	Description
< belső akció-1... n>	JSON-objektum	Egy vagy több művelet, amely a hatókörön belül fut
< műveletbemenetek>	JSON-objektum	Az egyes műveletek bemenetei

Kapcsolóművelet

Ez a művelet, más néven kapcsolóutasítás, esetekbe rendezi a többi műveletet, és minden esethez hozzárendel egy értéket, kivéve az alapértelmezett esetet, ha létezik ilyen. A munkafolyamat futtatásakor a Kapcsoló művelet összehasonlítja egy kifejezés, objektum vagy jogkivonat értékét az egyes esetekhez megadott értékekkel. Ha a Kapcsoló művelet talál egyező esetet, a munkafolyamat csak az adott eset műveleteit futtatja. A kapcsolóművelet minden futtatásakor vagy csak egy megfelelő eset létezik, vagy nincs egyezés. Ha nincs egyezés, a Kapcsoló művelet az alapértelmezett műveleteket futtatja. Megtudhatja, hogyan hozhat létre kapcsoló-utasításokat.

"Switch": {
   "type": "Switch",
   "expression": "<expression-object-or-token>",
   "cases": {
      "Case": {
         "actions": {
           "<action-name>": { "<action-definition>" }
         },
         "case": "<matching-value>"
      },
      "Case_2": {
         "actions": {
           "<action-name>": { "<action-definition>" }
         },
         "case": "<matching-value>"
      }
   },
   "default": {
      "actions": {
         "<default-action-name>": { "<default-action-definition>" }
      }
   },
   "runAfter": {}
}

Required

Value	Típus	Description
< expression-object-or-token>	Varies	A kiértékelendő kifejezés, JSON objektum vagy token
< művelet neve>	String	Az egyező esethez futtatandó művelet neve
< műveletdefiníció>	JSON-objektum	Az egyező esethez futtatandó művelet definíciója
< egyező érték>	Varies	A kiértékelt eredménnyel összehasonlítandó érték

Optional

Value	Típus	Description
< default-action-name>	String	Annak az alapértelmezett műveletnek a neve, amely akkor fut, ha nincs egyező eset
< default-action-definition>	JSON-objektum	A művelet definíciója, amely akkor fut, ha nincs egyező eset

Example

Ez a műveletdefiníció kiértékeli, hogy a jóváhagyási kérelemre válaszoló személy a "Jóváhagyás" vagy az "Elutasítás" lehetőséget választotta-e. E választás alapján a Kapcsoló művelet futtatja az egyező eset műveleteit, vagyis egy másik e-mailt küld a válaszadónak, de minden esetben más-más szöveggel.

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

Műveletig

Ez a ciklusművelet olyan műveleteket tartalmaz, amelyek addig futnak, amíg a megadott feltétel nem teljesül. A ciklus az összes többi művelet futtatása után utolsó lépésként ellenőrzi a feltételt. Az objektumba "actions" több műveletet is belefoglalhat, és a műveletnek legalább egy korlátot meg kell határoznia. Megtudhatja, hogyan hozhat létre "until" hurkokat.

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

Value	Típus	Description
< művelet neve>	String	A cikluson belül futtatni kívánt művelet neve
< művelettípus>	String	A futtatni kívánt művelettípus
< műveletbemenetek>	Various	A futtatandó művelet bemenetei
< feltétel>	String	A ciklus összes műveletének futtatása után kiértékelendő feltétel vagy kifejezés
< hurokszám>	Integer	A művelet által futtatható legtöbb ciklus korlátja. Az alapértelmezett korlátról és a maximális korlátról további információt az Azure Logic Apps korlátai és konfigurációja című témakörben talál.
< ciklusidőkorlát>	String	A ciklus futásának leghosszabb idejére vonatkozó korlát. Az alapértelmezett `timeout` érték a `PT1H`szükséges ISO 8601 formátum.

Note

Ha a kifejezés a Until ciklus bármely műveletének kimenetétől függ, ügyeljen arra, hogy figyelembe vegyen minden olyan hibát, amely az adott műveletből származhat.

Example

Ez a hurokművelet-definíció HTTP-kérést küld a megadott URL-címre, amíg az alábbi feltételek valamelyike nem teljesül:

A kérés "200 OK" állapotkóddal kap választ.
A hurok 60-szor fut.
A hurok egy órán át futott.

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

Webhookok és előfizetések

A webhook-alapú eseményindítók és műveletek nem ellenőrzik rendszeresen a végpontokat, hanem konkrét eseményekre vagy adatokra várnak ezeken a végpontokon. Ezek az eseményindítók és műveletek előfizetnek a végpontokra egy visszahívási URL-cím megadásával, ahol a végpont válaszokat küldhet.

A subscribe hívás akkor történik, ha a munkafolyamat bármilyen módon megváltozik, például amikor a hitelesítő adatok megújulnak, vagy amikor egy eseményindító vagy művelet bemeneti paraméterei megváltoznak. Ez a hívás ugyanazokat a paramétereket használja, mint a szabványos HTTP-műveletek.

A unsubscribe hívás automatikusan megtörténik, ha egy művelet érvénytelensé teszi az eseményindítót vagy a műveletet, például:

Az eseményindító törlése vagy letiltása.
A munkafolyamat törlése vagy letiltása.
Az előfizetés törlése vagy letiltása.

A hívások támogatásához a @listCallbackUrl() kifejezés egy egyedi "visszahívási URL-címet" ad vissza az eseményindítóhoz vagy a művelethez. Ez az URL a szolgáltatás REST API-ját használó végpontok egyedi azonosítóját jelöli. A függvény paraméterei megegyeznek a webhook triggerével vagy műveletével.

Aszinkron időtartam módosítása

Az eseményindítók és a műveletek esetében a tulajdonság hozzáadásával limit.timeout az aszinkron minta időtartamát egy adott időintervallumra korlátozhatja. Így ha a művelet nem fejeződött be az időköz lejártakor, a művelet állapota a kóddal Cancelled együtt lesz megjelölveActionTimedOut. A timeout tulajdonság ISO 8601 formátumot használ.

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

Futtatókörnyezet konfigurációs beállításai

Az eseményindítók és műveletek alapértelmezett futtatókörnyezeti viselkedését úgy módosíthatja, hogy hozzáadja ezeket runtimeConfiguration a tulajdonságokat az eseményindítóhoz vagy a műveletdefinícióhoz.

Property	Típus	Description	Eseményindító vagy művelet
`runtimeConfiguration.concurrency.runs`	Integer	Módosítsa az egyidejűleg (egyidejűleg vagy párhuzamosan) futtatható munkafolyamat-példányok számának alapértelmezett korlátját . Az érték módosítása segíthet korlátozni a háttérrendszerek által fogadott kérések számát. `runs` A tulajdonság `1` beállítása ugyanúgy működik, mint a `operationOptions` tulajdonság `SingleInstance`beállítása. Bármelyik tulajdonságot beállíthatja, de mindkettőt nem. Az alapértelmezett korlát módosításáról az eseményindító egyidejűségének vagy a triggerpéldányok egymást követő módosításáról olvashat.	Minden eseményindító
`runtimeConfiguration.concurrency.maximumWaitingRuns`	Integer	Módosítsa az alapértelmezett korlátot azon munkafolyamat-példányok számára, amelyeknek várniuk kell a futtatásra, ha a logikai alkalmazás már futtatja a maximális egyidejű példányokat. Az alapértelmezett korlát módosításáról a várakozási futtatások korlátjának módosítása című témakörben olvashat.	Minden eseményindító
`runtimeConfiguration.concurrency.repetitions`	Integer	Módosítsa az egyidejűleg (egyidejűleg vagy párhuzamosan) futtatható "minden" ciklus iterációjának alapértelmezett korlátját . `repetitions` A tulajdonság `1` beállítása ugyanúgy működik, mint a `operationOptions` tulajdonság `SingleInstance`beállítása. Bármelyik tulajdonságot beállíthatja, de mindkettőt nem. Az alapértelmezett korlát módosításához tekintse meg az "egyes" egyidejűség módosítása vagy az "egyes" ciklusok egymás utáni futtatása című témakört.	Action: Foreach
`runtimeConfiguration.paginationPolicy.minimumItemCount`	Integer	Azokat a műveleteket, amelyek támogatják és be vannak kapcsolva a lapozás, ez az érték határozza meg a lekérendő eredmények minimális számát. A lapozás bekapcsolásához olvassa el a Tömeges adatok, elemek vagy eredmények lekérése lapszámozással című témakört	Művelet: Változatos
`runtimeConfiguration.secureData.properties`	Array	Számos eseményindító és művelet esetén ezek a beállítások elrejtik a bemeneteket, kimeneteket vagy mindkettőt a logikai alkalmazás futtatási előzményeiből. További információ az adatok védelméről: Bemenetek és kimenetek elrejtése a futtatási előzményekből.	A legtöbb eseményindító és művelet
`runtimeConfiguration.staticResult`	JSON-objektum	Azokat a műveleteket, amelyek támogatják és be vannak kapcsolva a statikus eredménybeállítás , az `staticResult` objektum az alábbi attribútumokkal rendelkezik: - `name`, amely az aktuális művelet statikus eredménydefiníció nevére hivatkozik, amely a `staticResults` logikai alkalmazás munkafolyamatának `definition` attribútumában található attribútumban jelenik meg. További információ: Statikus eredmények – Sémahivatkozás a munkafolyamat-definíció nyelvéhez. - `staticResultOptions`, amely meghatározza, hogy a statikus eredmények érvényesek-e az aktuális műveletre `Enabled` vagy sem. A statikus eredmények bekapcsolásához lásd: Logikai alkalmazások tesztelése modelladatokkal statikus eredmények beállításával	Művelet: Változatos

Műveleti beállítások

Az eseményindítók és műveletek alapértelmezett viselkedését az eseményindító vagy a operationOptions műveletdefiníció tulajdonságával módosíthatja.

Művelet beállítás	Típus	Description	Eseményindító vagy művelet
`DisableAsyncPattern`	String	Futtassa a HTTP-alapú műveleteket szinkron módon, nem aszinkron módon. A beállítás beállításához tekintse meg a Műveletek szinkronizálása című témakört.	Actions: ApiConnection, HTTP, Response
`IncludeAuthorizationHeadersInOutputs`	String	Azon logikai alkalmazások esetében, amelyek engedélyezik az OAuth-ot a Microsoft Entra-azonosítóval a kérésalapú triggervégpont bejövő hívásainak engedélyezéséhez, az eseményindító kimeneteiben adja meg az `Authorization` OAuth hozzáférési jogkivonat fejlécét. További információ: "Engedélyezés" fejléc belefoglalása a kérelemindító kimeneteibe.	Triggers: Request, HTTP Webhook
`Sequential`	String	Futtassa a "for each" ciklus iterációit egyesével, nem pedig egyszerre párhuzamosan. Ez a beállítás ugyanúgy működik, mint a `runtimeConfiguration.concurrency.repetitions` tulajdonság `1`beállítása. Bármelyik tulajdonságot beállíthatja, de mindkettőt nem. A beállítás beállításához tekintse meg az "egyes" ciklusok egymás utáni futtatását.	Action: Foreach
`SingleInstance`	String	Futtassa az eseményindítót az egyes logikaialkalmazás-példányokhoz egymás után, és várja meg, amíg a korábban aktív futtatás befejeződik, mielőtt elindítja a következő logikaialkalmazás-példányt. Ez a beállítás ugyanúgy működik, mint a `runtimeConfiguration.concurrency.runs` tulajdonság `1`beállítása. Bármelyik tulajdonságot beállíthatja, de mindkettőt nem. A beállítás beállításához tekintse meg a triggerpéldányok egymás utáni beállítását.	Minden eseményindító
`SuppressWorkflowHeaders`	String	Ne küldjön `x-ms-*` metaadat-fejlécet kimenő kérésekben. Az Azure Logic Apps alapértelmezés szerint további metaadat-fejléceket is tartalmaz, `x-ms-` amelyek a kimenő kérések részeként a fejlécnév előtagját tartalmazzák. Egyes örökölt szolgáltatások azonban nem fogadnak el további ismeretlen fejlécekkel rendelkező kéréseket, ami sikertelen kéréseket eredményez.	Actions: HTTP, Function, APIManagement
`SuppressWorkflowHeadersOnResponse`	String	Ne küldjön `x-ms-*` metaadat-fejléceket a bejövő triggerkérelmeknek küldött válaszokban. Az Azure Logic Apps alapértelmezés szerint olyan bejövő kérésekre küld válaszokat, amelyek további metaadat-fejléceket tartalmaznak a `x-ms-` fejlécnév előtagjával. Egyes örökölt szolgáltatások azonban nem fogadnak el további ismeretlen fejlécekkel rendelkező kéréseket vagy válaszokat, ami sikertelen kéréseket eredményez.	Triggers: Request, HTTP Webhook

Triggerek egyidejűségének módosítása

Amikor bekapcsolja az eseményindító egyidejűségi vezérlőjét, a triggerpéldányok párhuzamosan futnak az alapértelmezett korlátig. Az alapértelmezett egyidejűségi korlát módosításához használhatja a kódnézet-szerkesztőt vagy a munkafolyamat-tervezőt, mert az egyidejűség beállításának módosítása a tervezőn keresztül hozzáadja vagy frissíti a runtimeConfiguration.concurrency.runs tulajdonságot az alapul szolgáló triggerdefinícióban, és fordítva. Ez a tulajdonság szabályozza a párhuzamosan futtatható új munkafolyamat-példányok maximális számát.

Mielőtt engedélyezi az egyidejűséget egy eseményindítón, tekintse át a következő szempontokat:

Az egyidejűség-vezérlés engedélyezése után nem tilthatja le az egyidejűséget.
Ha az egyidejű eseményindítók maximális száma eléri a párhuzamosság maximális fokát, az azt követő eseményindító-futtatások szabályozást vagy "429 – Túl sok kérés" hibát tapasztalhatnak. Ha olyan újrapróbálkozási szabályzatot állít be, amely 429 hibát kezel, az eseményindító újrapróbálkozási és szabályozási viselkedési ciklust tapasztalhat, amely hosszú késést okoz az új eseményindító-kérelmek feldolgozásában.
Ha az egyidejűség engedélyezve van, a tömbök leválasztása esetén a felosztási korlát jelentősen csökken. Ha az elemek száma meghaladja ezt a korlátot, a felosztási képesség le van tiltva.
Ha az egyidejűség engedélyezve van, a hosszú ideig futó logikaialkalmazás-példányok miatt az új logikaialkalmazás-példányok várakozási állapotba léphetnek. Ez az állapot megakadályozza, hogy az Azure Logic Apps új példányokat hozzon létre, és akkor is előfordul, ha az egyidejű futtatások száma kisebb, mint az egyidejű futtatások megadott maximális száma.
- Az állapot megszakításához szakítsa meg a még futó legkorábbi példányokat.
  1. A logikai alkalmazás menüjében válassza az Áttekintés lehetőséget.
  2. A Futtatási előzmények szakaszban válassza ki a még futó legkorábbi példányt, például:
    
    Tip
    
    Ha csak a még futó példányokat szeretné megtekinteni, nyissa meg az Összes listát, és válassza a Futtatás lehetőséget.
  3. A Logikai alkalmazás futtatása területen válassza a Futtatás megszakítása lehetőséget.
- A probléma elkerülése érdekében adjon hozzá időkorlátot minden olyan művelethez, amely késleltetheti a futtatásokat. Ha a kódszerkesztőben dolgozik, olvassa el az aszinkron időtartam módosítása című témakört. Ellenkező esetben, ha a tervezőt használja, kövesse az alábbi lépéseket:
  1. A logikai alkalmazás munkafolyamatában válassza ki azt a műveletet, amelyhez időtúllépést szeretne hozzáadni. A művelet jobb felső sarkában kattintson a három pontra (...), majd a Beállítások gombra.
  2. Az Időtúllépés csoportban adja meg az időtúllépés időtartamát ISO 8601 formátumban.
A logikai alkalmazás egymás utáni futtatásához állítsa az eseményindító egyidejűségét 1 a kódnézet-szerkesztő vagy a tervező használatával. Győződjön meg arról, hogy az eseményindító operationOptions tulajdonságát sem állítja SingleInstance be a kódnézet-szerkesztőben. Ellenkező esetben érvényesítési hiba jelenik meg. További információért lásd: Események egymás utáni indítása.

Szerkesztés kódnézetben

Az alapul szolgáló triggerdefinícióban adja hozzá a runtimeConfiguration.concurrency.runs tulajdonságot, és állítsa be az értéket az eseményindító egyidejűségi korlátai alapján. A munkafolyamat egymás utáni futtatásához állítsa a tulajdonság értékét a következőre 1: .

Ez a példa az egyidejű futtatásokat 10 példányra korlátozza:

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

További információ: Futtatókörnyezet konfigurációs beállításai.

Szerkesztés a munkafolyamat-tervezőben

Az eseményindító jobb felső sarkában válassza a három pont (...) gombot, majd válassza a Beállítások lehetőséget.
Az Egyidejűség-vezérlés csoportban állítsa be a KorlátotBe értékre.
Húzza a párhuzamosság foka csúszkát a kívánt értékre. A logikai alkalmazás egymás utáni futtatásához húzza a csúszkát 1 értékre.

Az "minden egyes" párhuzamosság módosítása

Alapértelmezés szerint a "minden" ciklus iterációja egyszerre fut (egyidejűleg vagy párhuzamosan). Ez a viselkedés azt jelenti, hogy az egyes iterációk elkezdődnek, mielőtt a korábbi iterációk befejeződnének. Az egyidejűleg futó iterációk száma azonban alapértelmezett korlátot szab. Amikor az egyidejűleg futó iterációk száma eléri ezt a korlátot, minden más iterációnak várnia kell a futtatásra.

Az alapértelmezett korlát módosításához használhatja a kódnézet-szerkesztőt vagy a munkafolyamat-tervezőt, mert az egyidejűség beállításának módosítása a tervezőn keresztül hozzáadja vagy frissíti a runtimeConfiguration.concurrency.repetitions tulajdonságot az alapul szolgáló "minden egyes" műveletdefinícióban, és fordítva. Ez a tulajdonság szabályozza a párhuzamosan futtatható iterációk maximális számát.

Note

Ha a "minden egyes" műveletet szekvenciálisan futtatja, akár a tervező, akár a kódnézet-szerkesztő használatával, ne állítsa be a művelet operationOptions tulajdonságát Sequential értékre a kódnézet-szerkesztőben. Ellenkező esetben érvényesítési hiba jelenik meg. További információért lásd: for-each ciklusok sorban futtatása.

Szerkesztés kódnézetben

Az alapértelmezett "foreach" definícióban adja hozzá vagy frissítse a runtimeConfiguration.concurrency.repetitions tulajdonságot, amelynek értéke 1 és 50 között lehet.

Íme egy példa, amely az egyidejű futtatásokat 10 iterációra korlátozza:

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

További információ: Futtatókörnyezet konfigurációs beállításai.

Szerkesztés a munkafolyamat-tervezőben

Az Egyes műveleteknél a jobb felső sarokban válassza a három pont (...) gombot, majd válassza a Beállítások lehetőséget.
Az Egyidejűség-vezérlés csoportban állítsa be az egyidejűség-vezérléstBe értékre.
Húzza a párhuzamosság foka csúszkát a kívánt értékre. A logikai alkalmazás egymás utáni futtatásához húzza a csúszkát 1 értékre.

Várakozási sorozatok korlátjának módosítása

Alapértelmezés szerint a logikai alkalmazás munkafolyamat-példányai egyszerre (egyidejűleg vagy párhuzamosan) futnak. Ez a viselkedés azt jelenti, hogy minden eseményindító-példány aktiválódik, mielőtt a korábban aktív munkafolyamat-példány fut. Az egyidejűleg futó munkafolyamat-példányok számára azonban létezik alapértelmezett korlát . Amikor az egyidejű futtatások száma eléri ezt a korlátot, minden más új munkafolyamat-példánynak várnia kell a futtatásra. A várakozó munkafolyamat-példányok száma is alapértelmezett korlátot szab. Amikor a várakozó példányok száma eléri ezt a korlátot, az Azure Logic Apps már nem fogadja el az új munkafolyamat-példányok futtatását. A kérelem- és webhook-eseményindítók 429-et adnak vissza – Túl sok kéréshiba, és az ismétlődő eseményindítók elkezdik kihagyni a lekérdezési kísérleteket.

Módosíthatja az eseményindító egyidejűségének alapértelmezett korlátját, valamint a várakozási futtatások alapértelmezett korlátját. Ez a változás azonban elsősorban lelassítja a triggert, hogy enyhítse a párhuzamosság okozta nyomást. Ha például lekérdezési eseményindítóval rendelkezik, és a várakozási sorok megteltek a folyamatban lévő futtatások miatt, az Azure Logic Apps leállítja a lekérdezést. Ha a munkafolyamat kérelemalapú eseményindítót használ, és a várakozási sorok megtelnek, az Azure Logic Apps elkezdi visszaadni a 429-es hibát. Vannak olyan esetek, amikor az Azure Logic Apps nem tudja leállítani az eseményindító lekérdezését hibák bevezetése nélkül, és úgy dönt, hogy mégis hozzáad ilyen futtatásokat a várólistához a hívásfuttatások meghiúsulása nélkül.

Az alapul szolgáló triggerdefinícióban adja hozzá a runtimeConfiguration.concurrency.maximumWaitingRuns tulajdonságot, amelynek értéke a következőtől 1 aig 100terjedhet.

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

További információ: Futtatókörnyezet konfigurációs beállításai.

Példányok egymást követő aktiválása

Ha az egyes logikaialkalmazás-munkafolyamat-példányokat csak az előző példány futtatása után szeretné futtatni, állítsa az eseményindítót egymás után futtatásra. Használhatja a kódnézet-szerkesztőt vagy a munkafolyamat-tervezőt, mert az egyidejűség beállításának tervezőn keresztüli módosítása szintén hozzáadja vagy frissíti a runtimeConfiguration.concurrency.runs tulajdonságot az alapul szolgáló triggerdefinícióban, és fordítva.

Note

Ha az eseményindítót egymás után futtatja a tervező vagy a kódnézet-szerkesztő használatával, ne állítsa az eseményindító tulajdonságát operationOptionsSequential a kódnézet-szerkesztőben. Ellenkező esetben érvényesítési hiba jelenik meg.

Szerkesztés kódnézetben

Az eseményindító definíciójában állítsa be valamelyik tulajdonságot, de mindkettőt nem.

Állítsa a runtimeConfiguration.concurrency.runs tulajdonságot az alábbira 1:

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

-or-

Állítsa a operationOptions tulajdonságot az alábbira SingleInstance:

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

További információ: Futtatókörnyezet konfigurációs beállításai és műveleti beállításai.

Szerkesztés a munkafolyamat-tervezőben

Az eseményindító jobb felső sarkában válassza a három pont (...) gombot, majd válassza a Beállítások lehetőséget.
Az Egyidejűség-vezérlés csoportban állítsa be a KorlátotBe értékre.
Húzza a párhuzamosság foka csúszkát a megadott számra 1.

Futtassa a "minden egyes" hurkokat egymás után

Ha csak az előző iteráció befejezése után szeretne "mindegyik" ciklus-iterációt futtatni, állítsa be az "egyes" lépést egymás utáni futtatásra. Használhatja a kódnézet-szerkesztőt vagy a munkafolyamat-tervezőt, mert a művelet egyidejűségének tervezőn keresztüli módosítása szintén hozzáadja vagy frissíti a runtimeConfiguration.concurrency.repetitions tulajdonságot a mögöttes műveletdefinícióban, és fordítva.

Note

Ha "for each" műveletet állít be úgy, hogy az sorrendben fusson, akár a tervezőt, akár a kódnézet szerkesztőt használva, ne állítsa be a művelet operationOptions tulajdonságát Sequential-ra a kódnézet szerkesztőben. Ellenkező esetben érvényesítési hiba jelenik meg.

Szerkesztés kódnézetben

A műveletdefinícióban állítsa be valamelyik tulajdonságot, de mindkettőt nem.

Állítsa a runtimeConfiguration.concurrency.repetitions tulajdonságot az alábbira 1:

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

-or-

Állítsa a operationOptions tulajdonságot az alábbira Sequential:

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

További információ: Futtatókörnyezet konfigurációs beállításai és műveleti beállításai.

Szerkesztés a munkafolyamat-tervezőben

Az egyes műveletek jobb felső sarkában válassza a három pont (...) gombot, majd válassza a Beállítások lehetőséget.
Az Egyidejűség-vezérlés csoportban állítsa be az egyidejűség-vezérléstBe értékre.
Húzza a párhuzamosság foka csúszkát a megadott számra 1.

Műveletek futtatása szinkron műveleti mintában

Az Azure Logic Apps HTTP- és APIConnection-műveletei alapértelmezés szerint a szabványos aszinkron műveleti mintát követik, míg a Válasz művelet a szinkron műveleti mintát követi. Az aszinkron minta azt határozza meg, hogy miután egy művelet meghívja vagy elküldi a kérést a megadott végpontnak, szolgáltatásnak, rendszernek vagy API-nak, a fogadó azonnal "202 ACCEPTED" választ ad vissza. Ez a kód megerősíti, hogy a fogadó elfogadta a kérést, de még nem fejezte be a feldolgozást. A válasz tartalmazhat egy location fejlécet, amely megadja az URL-címet és egy frissítési azonosítót, amellyel a hívó folyamatosan lekérdezheti vagy ellenőrizheti az aszinkron kérés állapotát, amíg a fogadó le nem állítja a feldolgozást, és "200 OK" sikeres választ vagy más, nem 202-től eltérő választ ad vissza. További információ: Aszinkron mikroszolgáltatás-integráció kényszeríti a mikroszolgáltatások autonómiáját.

A Logic App Designerben a HTTP-művelet, az APIConnection-műveletek és a válaszművelet aszinkron mintabeállítással rendelkezik. Ha engedélyezve van, ez a beállítás azt határozza meg, hogy a hívó nem várja meg a feldolgozás befejezését, és továbbléphet a következő műveletre, de a feldolgozás befejezéséig folytatja az állapot ellenőrzését. Ha le van tiltva, ez a beállítás azt határozza meg, hogy a hívó megvárja a feldolgozás befejezését, mielőtt továbblépne a következő műveletre. A beállítás megkereséséhez kövesse az alábbi lépéseket:
1. A HTTP-művelet címsorában válassza a három pont (...) gombot, amely megnyitja a művelet beállításait.
2. Keresse meg az Aszinkron minta beállítást.
A művelet mögöttes JavaScript Object Notation (JSON) definíciójában a HTTP-művelet és az APIConnection-műveletek implicit módon követik az aszinkron műveleti mintát.

Bizonyos esetekben előfordulhat, hogy egy művelet inkább a szinkron mintát követi. Ha például a HTTP-műveletet használja, érdemes lehet:

Ezekben az esetekben az alábbi beállításokkal szinkronizálhatja a műveletet:

Ha elérhető, cserélje le a művelet lekérdezési verzióját egy webhook-verzióra.
Tiltsa le a művelet aszinkron viselkedését a következő egyik lehetőséggel:
- A Logic App Designerben kapcsolja ki az Aszinkron minta beállítást.
- A művelet alapjául szolgáló JSON-definícióban adja hozzá a "DisableAsyncPattern" műveleti lehetőséget.

Az Aszinkron minta beállítás kikapcsolása

A Logic App Designerben a művelet címsorában válassza a három pont (...) gombot, amely megnyitja a művelet beállításait.
Keresse meg az Aszinkron minta beállítást, kapcsolja ki a beállítást , ha engedélyezve van, és válassza a Kész lehetőséget.

Aszinkron minta letiltása a művelet JSON-definíciójában

A művelet mögöttes JSON-definíciójában adja hozzá és állítsa be az "operationOptions" tulajdonságot"DisableAsyncPattern" a művelet szakaszában "inputs" , például:

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

Triggerek és műveletek hitelesítése

A HTTP- és HTTPS-végpontok különböző típusú hitelesítést támogatnak. A végpontok elérésére irányuló kimenő hívások vagy kérések indításához használt eseményindító vagy művelet alapján különböző hitelesítési típusok közül választhat. További információ: Hitelesítés hozzáadása kimenő hívásokhoz.

Következő lépések

További információ a munkafolyamat-definíció nyelvéről

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-09-17

Megosztás a következőn keresztül:

Sémahivatkozási útmutató eseményindítókhoz és művelettípusokhoz az Azure Logic Appsben

Triggerek áttekintése

Triggertípusok listája

Beépített triggerek

Felügyelt API-eseményindítók

Triggerek – Részletes referencia

APIConnection-eseményindító

ApiConnectionWebhook eseményindító

HTTP-eseményindító

HTTPWebhook-eseményindító

Ismétlődési eseményindító

Kérelem eseményindítója

Triggerfeltételek

Több munkafolyamat-futtatás aktiválása tömbön

A debatching bekapcsolása a tervezőn keresztül

A debatching bekapcsolása az eseményindító definíciójában

Műveletek áttekintése

Művelettípusok listája

Beépített műveletek

Felügyelt API-műveletek

Munkafolyamat-műveletek vezérlése

Műveletek – Részletes referencia

APIConnection művelet

APIConnectionWebhook művelet

Írási művelet

JavaScript Code-művelet végrehajtása

Függvényművelet

HTTP-művelet

Csatlakozás művelet

JSON-művelet elemzése

Lekérdezési művelet

Válaszművelet

Művelet kiválasztása

Táblaművelet

Művelet leállítható

Várakozási művelet

Munkafolyamat-művelet

Munkafolyamat-művelet részleteinek szabályozása

Foreach művelet

Ha a művelet

Kifejezések használata a feltételekben

Hatókörművelet

Kapcsolóművelet

Műveletig

Webhookok és előfizetések

Aszinkron időtartam módosítása

Futtatókörnyezet konfigurációs beállításai

Műveleti beállítások

Triggerek egyidejűségének módosítása

Szerkesztés kódnézetben

Szerkesztés a munkafolyamat-tervezőben

Az "minden egyes" párhuzamosság módosítása

Szerkesztés kódnézetben

Szerkesztés a munkafolyamat-tervezőben

Várakozási sorozatok korlátjának módosítása

Példányok egymást követő aktiválása

Szerkesztés kódnézetben

Szerkesztés a munkafolyamat-tervezőben

Futtassa a "minden egyes" hurkokat egymás után

Szerkesztés kódnézetben

Szerkesztés a munkafolyamat-tervezőben

Műveletek futtatása szinkron műveleti mintában

Az Aszinkron minta beállítás kikapcsolása

Aszinkron minta letiltása a művelet JSON-definíciójában

Triggerek és műveletek hitelesítése

Következő lépések

Visszajelzés

További források