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 Csatlakozás orok áttekintésében található listát.
Eseményindítók á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>"
},
Szükséges
Value | Type | Description |
---|---|---|
<eseményindító neve> | Sztring | Az eseményindító neve |
<eseményindító típusa> | Sztring | Az eseményindító típusa, például "Http" vagy "Api Csatlakozás ion" |
<trigger-bemenetek> | JSON-objektum | Az eseményindító viselkedését meghatározó bemenetek |
<időegység> | Sztring | Az eseményindító által aktivált eseményindítók gyakoriságát leíró időegység: "Second", "Minute", "Hour", "Day", "Week", "Month" |
<időegységek száma> | Egész | 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. |
Választható
Value | Type | Description |
---|---|---|
<tömb feltételekkel> | Tömb | 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> | Sztring | 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> | Sztring | 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 | Leírás |
---|---|
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 202 aszinkron mintával vagy egy tömb visszaadásával. |
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. |
Ismétlődés | Meghatározott ütemezés alapján aktiválódik. 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. |
Kérelem | 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 | Leírás |
---|---|
ApiConnection | Egy végpontot a Microsoft által felügyelt API-k vagy "összekötők" használatával ellenőriz vagy kérdez le. |
Api Csatlakozás ionWebhook | 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
API Csatlakozás ion trigger
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>"
}
Szükséges
Value | Type | Description |
---|---|---|
<API Csatlakozásion_trigger_name> | Sztring | Az eseményindító neve |
<kapcsolat neve> | Sztring | A munkafolyamat által használt felügyelt API-kapcsolat neve |
<metódustípus> | Sztring | A felügyelt API-val való kommunikáció HTTP-metódusa: "GET", "PUT", "POST", "PATCH", "DELETE" |
<api-operation> | Sztring | A meghívandó API-művelet |
<időegység> | Sztring | Az eseményindító által aktivált eseményindítók gyakoriságát leíró időegység: "Second", "Minute", "Hour", "Day", "Week", "Month" |
<időegységek száma> | Egész | 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. |
Választható
Value | Type | 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 ?api-version=2018-01-01 a hívást. |
<maximális futtatások> | Egész | 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> | Egész | 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> | Sztring | Tömböket visszatűnő eseményindítók 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: |
<operation-option> | Sztring | 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. |
Kimenetek
Elem | Type | Description |
---|---|---|
Fejlécek | JSON-objektum | A válasz fejlécei |
törzs | JSON-objektum | A válasz törzse |
állapotkód | Egész | A válasz állapotkódja |
Példa
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
}
}
Api Csatlakozás ionWebhook 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>"
}
Szükséges
Value | Type | Description |
---|---|---|
<kapcsolat neve> | Sztring | 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 |
Választható
Value | Type | 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 |
<maximális futtatások> | Egész | 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> | Egész | 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> | Sztring | Tömböket visszatűnő eseményindítók 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: |
<operation-option> | Sztring | 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. |
Példa
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>"
}
Szükséges
Tulajdonság | Érték | Type | Description |
---|---|---|---|
method |
<metódustípus> | Sztring | 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> | Sztring | 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> | Sztring | Az eseményindító által aktivált eseményindítók gyakoriságát leíró időegység: "Second", "Minute", "Hour", "Day", "Week", "Month" |
interval |
<időegységek száma> | Egész | 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. |
Választható
Tulajdonság | Érték | Type | 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:
|
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 |
body |
<törzs-tartalom> | JSON-objektum | A kéréssel együtt küldendő üzenet tartalma hasznos adatként |
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> | Egész | 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> | Egész | 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> | Sztring | 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. |
Kimenetek
Elem | Type | Description |
---|---|---|
headers |
JSON-objektum | A válasz fejlécei |
body |
JSON-objektum | A válasz törzse |
status code |
Egész | 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:
Tulajdonság | Kötelező | Leírás |
---|---|---|
Állapotkód | Igen | 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 | Nem | Másodpercek száma, amíg a logikai alkalmazás újra le nem kérdezi a végpontot |
Hely fejléce | Nem | 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 | Működés |
---|---|---|
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} | Hibás kérés, 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. |
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ók aszinkron 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.
Szükséges
Value | Type | Description |
---|---|---|
<metódustípus> | Sztring | Az előfizetési kérelem http-metódusa: "GET", "PUT", "POST", "PATCH" vagy "DELETE" |
<endpoint-subscribe-URL> | Sztring | A végpont URL-címe, ahová el szeretné küldeni az előfizetési kérelmet |
Választható
Value | Type | Description |
---|---|---|
<metódustípus> | Sztring | A lemondási kérelemhez használt HTTP-metódus: "GET", "PUT", "POST", "PATCH" vagy "DELETE" |
<endpoint-unsubscribe-URL> | Sztring | A végpont URL-címe, ahová el szeretné küldeni a lemondási kérelmet |
<törzs-tartalom> | Sztring | 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> | Egész | 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> | Egész | 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> | Sztring | 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. |
Kimenetek
Elem | Type | Description |
---|---|---|
Fejlécek | JSON-objektum | A válasz fejlécei |
törzs | JSON-objektum | A válasz törzse |
állapotkód | Egész | A válasz állapotkódja |
Példa
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>"
}
Szükséges
Value | Type | Description |
---|---|---|
<időegység> | Sztring | Az eseményindító által aktivált eseményindítók gyakoriságát leíró időegység: "Second", "Minute", "Hour", "Day", "Week", "Month" |
<időegységek száma> | Egész | 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. |
Választható
Value | Type | Description |
---|---|---|
<start-date-time-with-format-YYYY-MM-DDThh:mm:ss> | Sztring | A kezdő dátum és időpont ebben a formátumban: YYYY-MM-DDThh:mm:ss, ha időzónát ad meg -Vagy- 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> | Sztring | 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> | Egész | 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> | Egész | 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> | Sztring | 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.
Az eseményindító meghívásához a listCallbackUrl
Munkafolyamat-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.
"manual": {
"type": "Request",
"kind": "Http",
"inputs": {
"method": "<method-type>",
"relativePath": "<relative-path-for-accepted-parameter>",
"schema": {
"type": "object",
"properties": {
"<property-name>": {
"type": "<property-type>"
}
},
"required": [ "<required-properties>" ]
}
},
"runTimeConfiguration": {
"concurrency": {
"runs": <max-runs>,
"maximumWaitingRuns": <max-run-queue>
},
},
"operationOptions": "<operation-option>"
}
Szükséges
Value | Type | Description |
---|---|---|
<tulajdonság-név> | Sztring | A JSON-séma egyik tulajdonságának neve, amely a hasznos adatokat írja le |
<tulajdonságtípus> | Sztring | A tulajdonság típusa |
Választható
Value | Type | Description |
---|---|---|
<metódustípus> | Sztring | A bejövő kérések metódusa a következő logikai alkalmazás meghívásához használható: "GET", "PUT", "POST", "PATCH", "DELETE" |
<relative-path-for-accepted-parameter> | Sztring | Annak a paraméternek a relatív elérési útja, amelyet a végpont URL-címe elfogadhat |
<kötelező tulajdonságok> | Tömb | Egy vagy több olyan tulajdonság, amely értékeket igényel |
<maximális futtatások> | Egész | 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> | Egész | 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> | Sztring | 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. |
Példa
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:
"manual": {
"type": "Request",
"kind": "Http",
"inputs": {
"method": "POST",
"schema": {
"type": "object",
"properties": {
"customerName": {
"type": "String"
},
"customerAddress": {
"type": "Object",
"properties": {
"streetAddress": {
"type": "string"
},
"city": {
"type": "string"
}
}
}
}
}
}
}
Aktiválási feltételek
Bármely eseményindítóhoz és csak eseményindítókhoz tartalmazhat olyan tömböt, amely egy vagy több kifejezést tartalmaz a munkafolyamat futtatását meghatározó feltételekhez. 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 futtatás aktiválása tömbön
Ha az eseményindító egy tömböt kap a munkafolyamat feldolgozásához, előfordulhat, hogy az egyes tömbelemek feldolgozása túl hosszú időt vesz igénybe. Ehelyett az eseményindító SplitOn tulajdonságával feloldhatja a tömböt. A feloldás felosztja a tömbelemeket, és elindít egy új munkafolyamat-példányt, amely minden tömbelemhez fut. Ez a módszer 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.
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óhoz. Ellenkező esetben adja hozzá ezt a tulajdonságot a válasz hasznos adatai közé, amely a feloldani kívánt tömböt használja.
A SplitOn funkció használata előtt tekintse át a következő szempontokat:
Ha az eseményindító egyidejűsége engedélyezve van, a SplitOn korlátja jelentősen csökken. Ha az elemek száma meghaladja ezt a korlátot, a SplitOn funkció le van tiltva.
A SplitOn funkció nem használható szinkron válaszmintával. A SplitOn tulajdonságot használó és válaszműveleteket tartalmazó munkafolyamatok aszinkron módon futnak, és azonnal választ küldenek
202 ACCEPTED
.A SplitOn által egyetlen munkafolyamat-futtatás során feldolgozható tömbelemek maximális számát a Korlátok és a konfiguráció című témakörben találja.
Példa
Tegyük fel, hogy van egy HTTP-eseményindítója, amely meghív egy API-t, és megkapja ezt a választ:
{
"Status": "Succeeded",
"Rows": [
{
"id": 938109380,
"name": "customer-name-one"
},
{
"id": 938109381,
"name": "customer-name-two"
}
]
}
A munkafolyamatnak csak a tömbből Rows
származó tartalomra van szüksége, így az alábbi példához hasonló eseményindítót hozhat létre:
"HTTP_Debatch": {
"type": "Http",
"inputs": {
"uri": "https://mydomain.com/myAPI",
"method": "GET"
},
"recurrence": {
"frequency": "Second",
"interval": 1
},
"splitOn": "@triggerBody()?.Rows"
}
Megjegyzés:
Ha a SplitOn
parancsot használja, nem szerezheti be a tömbön kívüli tulajdonságokat.
Ezért ebben a példában nem lehet lekérni a status
tulajdonságot az API-ból visszaadott válaszban.
A hiba elkerülése érdekében, ha a Rows
tulajdonság nem létezik, ez a példa az operátort ?
használja.
A munkafolyamat-definíció mostantól az első futtatásból és "customer-name-two"
a name
második futtatásból származó értékek "customer-name-one"
lekérésére használható@triggerBody().name
. Az eseményindító kimenetei így 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>"
},
Szükséges
Value | Type | Description |
---|---|---|
<művelet neve> | Sztring | A művelet neve |
<művelettípus> | Sztring | A művelet típusa, például "Http" vagy "Api Csatlakozás ion" |
<bemeneti név> | Sztring | A művelet viselkedését meghatározó bemenet neve |
<bemeneti érték> | Különböző | 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 |
Választható
Value | Type | 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> | Sztring | 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 például az Api Csatlakozás ion és az Api Csatlakozás ionWebHook, 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 Bus, az Office 365 Outlook, a Power BI, az Azure Blob Storage, a OneDrive, a GitHub stb.
Olyan munkafolyamat-művelettípusok szabályozása, mint például a Ha, a Foreach, a Kapcsoló, a Hatókör és a Until, amelyek más műveleteket tartalmaznak, és segítenek a munkafolyamat-végrehajtás rendszerezésében
Beépített műveletek
Művelettípus | Leírás |
---|---|
Összeállítás | Egyetlen kimenetet hoz létre bemenetekből, amelyek különböző típusúak lehetnek. |
JavaScript-kód végrehajtása | Futtassa az adott 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. |
Függvény | Azure-függvényt hív meg. |
HTTP | HTTP-végpontot hív meg. |
Csatlakozás | 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 jogkivonatokat hoz létre a JSON-tartalom tulajdonságaiból. Ezután hivatkozhat ezekre a tulajdonságokra a logikai alkalmazás jogkivonatainak beleszámítva. |
Lekérdezés | Egy feltétel vagy szűrő alapján létrehoz egy tömböt egy másik tömb elemeiből. |
Válasz | Választ hoz létre egy bejövő hívásra vagy kérésre. |
Kiválasztás | 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. |
Befejezés | Leállítja az aktívan futó munkafolyamatot. |
Várakozás | Szünetelteti a munkafolyamatot egy megadott időtartamra vagy a megadott dátumig és időpontig. |
Munkafolyamat | Munkafolyamatot ágyaz be egy másik munkafolyamatba. |
Felügyelt API-műveletek
Művelettípus | Leírás |
---|---|
ApiConnection | HTTP-végpont meghívása Microsoft által felügyelt API használatával. |
Api Csatlakozás ionWebhook | 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 | Leírás |
---|---|
ForEach | Futtassa ugyanazokat a műveleteket egy ciklusban egy tömb minden eleméhez. |
Ha | Futtassa a műveleteket attól függően, hogy a megadott feltétel igaz vagy hamis. |
Hatókör | 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. |
Amíg | Futtassa a műveleteket egy ciklusban, amíg a megadott feltétel nem teljesül. |
Műveletek – Részletes referencia
API Csatlakozás ion 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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<művelet neve> | Sztring | Az összekötő által megadott művelet neve |
<api-name> | Sztring | A kapcsolathoz használt Microsoft által felügyelt API neve |
<metódustípus> | Sztring | Az API meghívásának HTTP-metódusa: "GET", "PUT", "POST", "PATCH" vagy "DELETE" |
<api-operation> | Sztring | A meghívandó API-művelet |
Választható
Value | Type | 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 |
<egyéb műveletspecifikus tulajdonságok> | JSON-objektum | Az adott műveletre vonatkozó egyéb tulajdonságok |
Példa
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": {}
}
API Csatlakozás ionWebhook 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.
Szükséges
Value | Type | Description |
---|---|---|
<művelet neve> | Sztring | Az összekötő által megadott művelet neve |
<metódustípus> | Sztring | A végpontról való feliratkozáshoz vagy leiratkozáshoz használható HTTP-metódus: "GET", "PUT", "POST", "PATCH" vagy "DELETE" |
<api-subscribe-URL> | Sztring | Az API-ra való feliratkozáshoz használandó URI |
Választható
Value | Type | Description |
---|---|---|
<api-unsubscribe-URL> | Sztring | Az API-ról való leiratkozáshoz használandó URI |
<fejléc-tartalom> | JSON-objektum | A kérésbe küldendő fejlécek Például egy kérés nyelvének és típusának beállításához:
|
<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 |
<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 Api Csatlakozás ionWebhook-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": {}
},
Szükséges
Value | Type | Description |
---|---|---|
<inputs-to-compose> | Any | Az egyetlen kimenet létrehozásához szükséges bemenetek |
1\. példa
Ez a műveletdefiníció összefésül abcdefg
egy záró szóközzel és az értékkel 1234
:
"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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<JavaScript-code-snippet> | Eltérő | 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. Az attribútumban a |
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 megadhat értékeket vagy false
értékekettrue
.
Value | Type | 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ére hivatkozik a tulajdonság írásvédett workflowContext
objektumon keresztüli workflowContext.workflow.name
elérésével. Az objektum használatával kapcsolatos további információkért lásd: workflowContext
Referencia-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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<Azure-function-ID> | Sztring | 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> | Sztring | 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. |
Választható
Value | Type | Description |
---|---|---|
<fejléc-tartalom> | JSON-objektum | A hívással küldendő fejlécek Például egy kérés nyelvének és típusának beállításához:
|
<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 |
<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 a Logic Apps motor 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.
A Logic Apps motor 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.
Példa
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": {}
}
Szükséges
Tulajdonság | Érték | Type | Description |
---|---|---|---|
method |
<metódustípus> | Sztring | 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> | Sztring | 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. |
Választható
Tulajdonság | Érték | Type | 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:
|
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 |
body |
<törzs-tartalom> | JSON-objektum | A kéréssel együtt küldendő üzenet tartalma hasznos adatként |
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 |
Példa
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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<Tömb> | Tömb | 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. |
<Határoló> | Egy karakterből álló sztring | Az a karakter, amely elválasztja a sztring egyes elemeit |
Példa
Tegyük fel, hogy már létrehozott egy korábban létrehozott "myIntegerArray" változót, amely az egész 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. Ezeket a tulajdonságokat ezután a logikai alkalmazásban a jogkivonatok 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": {}
},
Szükséges
Value | Type | 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 Logic Apps Tervező megadhatja a sémát, vagy megadhat egy hasznos adatmintát, hogy a művelet létrehozhassa a sémát. |
Példa
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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<Tömb> | Tömb | 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ő> | Sztring | 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. |
Példa
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": {}
},
Szükséges
Value | Type | Description |
---|---|---|
<response-status-code> | Egész | 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. |
Választható
Value | Type | Description |
---|---|---|
<válaszfejlécek> | JSON-objektum | Egy vagy több fejléc, amely szerepel a válaszban |
<választörzs> | Különböző | A válasz törzse, amely lehet sztring, JSON-objektum vagy akár bináris tartalom egy korábbi műveletből |
Példa
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": {}
}
Korlátozások
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 a PUT metódus használatakor, és ha igaz, "rossz kérés" választ ad vissza.
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": {}
},
Szükséges
Value | Type | Description |
---|---|---|
<Tömb> | Tömb | 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> | Sztring | A kifejezés 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> | Sztring | Az a kifejezés, amely átalakítja az elemet a forrástömbben, és az eredményt kulcsnévhez <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.
Példa
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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<CSV vagy HTML> | Sztring | A létrehozni kívánt táblázat formátuma |
<Tömb> | Tömb | 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. |
Választható
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 | Type | Description |
---|---|---|
<oszlopnév> | Sztring | 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 tulajdonság által használt kifejezés lekéri from
a tömböt a "myItemArray" függvényből a variables()
következő függvény használatával:
"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 tulajdonság által használt kifejezés lekéri from
a tömböt a "myItemArray" függvényből a variables()
következő függvény használatával:
"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 | Alma |
1 | Narancs |
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 | Leírás |
---|---|
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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<status> | Sztring | A futtatáshoz visszatérendő állapot: "Sikertelen", "Megszakítva", vagy "Sikeres" |
Választható
A "runStatus" objektum tulajdonságai csak akkor érvényesek, ha a "runStatus" tulajdonság "Sikertelen" állapotra van állítva.
Value | Type | Description |
---|---|---|
<hibakód vagy név> | Sztring | A hiba kódja vagy neve |
<hibaüzenet> | Sztring | A hibát leíró üzenet vagy szöveg, valamint az alkalmazásfelhasználó által végrehajtható műveletek |
Példa
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": {}
},
Szükséges
Value | Type | Description |
---|---|---|
<egységek száma> | Egész | A Késleltetés műveletnél a várakozni kívánt egységek száma |
<interval> | Sztring | 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> | Sztring | 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.
A Logic Apps motor 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ás
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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<beágyazott-logic-app-name> | Sztring | A meghívni kívánt logikai alkalmazás neve |
<eseményindító neve> | Sztring | A meghívni kívánt beágyazott logikai alkalmazás eseményindítójának neve |
<Azure-subscription-ID> | Sztring | A beágyazott logikai alkalmazás Azure-előfizetés-azonosítója |
<Azure-erőforráscsoport> | Sztring | A beágyazott logikai alkalmazás Azure-erőforráscsoportjának neve |
Választható
Value | Type | Description |
---|---|---|
<fejléc-tartalom> | JSON-objektum | A hívással küldendő fejlécek |
<törzs-tartalom> | JSON-objektum | A hívással küldendő üzenettartalmak |
Kimenetek
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.
Példa
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 a ciklusművelet végighalad egy tömbön, és műveleteket hajt végre minden tömbelemen. Alapértelmezés szerint az "egyes" ciklusok párhuzamosan futnak, legfeljebb a ciklusok maximális számáig. Ehhez a maximális értékhez tekintse meg a korlátokat és a konfigurációt. Ismerje meg , hogyan hozhat létre "minden" 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>"
}
Szükséges
Value | Type | Description |
---|---|---|
<action-1... N> | Sztring | Az egyes tömbelemeken futó műveletek neve |
<action-definition-1... N> | JSON-objektum | A futtatott műveletek definíciói |
<for-each-expression> | Sztring | Az a kifejezés, amely a megadott tömb minden elemére hivatkozik |
Választható
Value | Type | Description |
---|---|---|
<count> | Egész | 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> | Sztring | 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ó: "minden egyes" ciklus futtatása egymás után. |
Példa
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 a mellékletet is tartalmazó 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 | Type | Description |
---|---|---|
<Feltétel> | JSON-objektum | A feltétel, amely lehet kifejezés, a kiértékelésre |
<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 |
Az objektumok vagy else
objektumok műveletei a actions
következő állapotokat kapják:
- "Sikeres" a futtatás és a sikeresség esetén
- "Sikertelen" a futtatás és a sikertelenség esetén
- "Kihagyva", ha a megfelelő ág nem fut
Példa
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 | Eredmény |
---|---|
"kifejezés": "@parameters('<hasSpecialAction>')" | Csak logikai kifejezések esetén a feltétel minden olyan értéknek megfelel, 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: |
"kifejezés": "@greater(actions('action>'<).output.value, parameters('threshold>'<))" | Összehasonlító függvények esetén a művelet csak akkor fut, ha a művelet> kimenete< meghaladja a <küszöbértéket>. |
"kifejezés": "@or(greater(actions('action>'<).output.value, parameters('threshold>'<)), 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 művelet> kimenete< meghaladja a< küszöbértéket> vagy 100 alatt van. |
"kifejezés": "@equals(length(actions('action>'<).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": {}
}
}
}
Szükséges
Value | Type | 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 |
Switch 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": {}
}
Szükséges
Value | Type | Description |
---|---|---|
<expression-object-or-token> | Eltérő | A kiértékelendő kifejezés, JSON-objektum vagy jogkivonat |
<művelet neve> | Sztring | Az egyező esethez futtatandó művelet neve |
<műveletdefiníció> | JSON-objektum | Az egyező esethez futtatandó művelet definíciója |
<egyező érték> | Eltérő | A kiértékelt eredménnyel összehasonlítandó érték |
Választható
Value | Type | Description |
---|---|---|
<default-action-name> | Sztring | 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 |
Példa
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 | Type | Description |
---|---|---|
<művelet neve> | Sztring | A cikluson belül futtatni kívánt művelet neve |
<művelettípus> | Sztring | A futtatni kívánt művelettípus |
<műveletbemenetek> | Különböző | A futtatandó művelet bemenetei |
<Feltétel> | Sztring | A ciklus összes műveletének futtatása után kiértékelendő feltétel vagy kifejezés |
<hurokszám> | Egész | 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> | Sztring | A ciklus futásának leghosszabb ideje. Az alapértelmezett timeout érték a PT1H szükséges ISO 8601 formátum. |
Megjegyzés:
Ha a kifejezés a Until ciklus bármely műveletének kimenetétől függ, győződjön meg arról, hogy az adott műveletből eredő hibákért felelős.
Példa
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 fut.
"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 ActionTimedOut
együtt lesz megjelölveCancelled
. 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.
Tulajdonság | Type | Description | Eseményindító vagy művelet |
---|---|---|---|
runtimeConfiguration.concurrency.runs |
Egész | 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.
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 |
Egész | 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 |
Egész | Módosítsa az egyidejűleg (egyidejűleg vagy párhuzamosan) futtatható "minden" ciklus iterációjának alapértelmezett korlátját.
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. |
Akció: |
runtimeConfiguration.paginationPolicy.minimumItemCount |
Egész | 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 |
Tömb | 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: - - 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 | Type | Description | Eseményindító vagy művelet |
---|---|---|---|
DisableAsyncPattern |
Sztring | 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. |
Műveletek: |
IncludeAuthorizationHeadersInOutputs |
Sztring | 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. |
Eseményindítók: |
Sequential |
Sztring | Futtassa az "mindegyikhez" ciklus iterációit egyenként, nem pedig egyszerre párhuzamosan. Ez a beállítás ugyanúgy működik, mint a A beállítás beállításához tekintse meg az "egyes" ciklusok egymás utáni futtatását. |
Akció: |
SingleInstance |
Sztring | 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 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 |
Sztring | Ne küldjön x-ms-* metaadat-fejléceket kimenő kérésekben. Az Azure Logic Apps szolgáltatás alapértelmezés szerint további metaadat-fejléceket tartalmaz, x-ms- amelyek a kimenő kérések részeként az előtagot tartalmazzák a fejlécnévben. 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. |
Műveletek: |
SuppressWorkflowHeadersOnResponse |
Sztring | Ne küldjön x-ms-* metaadat-fejléceket a bejövő triggerkérelmeknek küldött válaszokban. Az Azure Logic Apps szolgáltatás 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. |
Eseményindítók: |
Trigger egyidejűségének 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ó példányok száma azonban alapértelmezett korlátot szab. Amikor az egyidejűleg futó munkafolyamat-példányok száma eléri ezt a korlátot, a többi új példánynak várnia kell a futtatásra. Ez a korlát segít szabályozni a háttérrendszerek által fogadott kérések számát.
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 Logic Apps Tervező, 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 SplitOn-korlát jelentősen csökken a tömbök leválasztására. Ha az elemek száma meghaladja ezt a korlátot, a SplitOn funkció 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.
A logikai alkalmazás menüjében válassza az Áttekintés lehetőséget.
A Futtatási előzmények szakaszban válassza ki a még futó legkorábbi példányt, például:
Tipp.
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.
A Logikai alkalmazás futtatása területen válassza a Futtatás megszakítása lehetőséget.
A lehetőség megkerüléséhez adjon hozzá időtúllépést minden olyan művelethez, amely visszatarthatja ezeket 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:
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 válassza a három pont (...) gombot, majd válassza a Gépház.
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ó tulajdonságátSingleInstance
sem állítjaoperationOptions
be a kódnézet-szerkesztőben. Ellenkező esetben érvényesítési hiba jelenik meg. További információ: Triggerpéldányok egymás után.
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 Logic Apps Tervező
Az eseményindító jobb felső sarkában válassza a három pont (...) gombot, majd válassza a Gépház.
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 "egyes" egyidejűsé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 az előző iteráció futtatása előtt indulnak el. 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 Logic Apps Tervező, 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" 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.
Megjegyzés:
Ha az "egyes" műveletet egymás után futtatja a tervező vagy a kódnézet-szerkesztő használatával, ne állítsa a művelet tulajdonságát operationOptions
Sequential
a kódnézet-szerkesztőben. Ellenkező esetben érvényesítési hiba jelenik meg. További információ: "minden egyes" ciklus futtatása egymás után.
Szerkesztés kódnézetben
Az alapul szolgáló "minden" definícióban adja hozzá vagy frissítse a runtimeConfiguration.concurrency.repetitions
tulajdonságot, amelynek értéke 1
az és 50
a .
Í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 Logic Apps Tervező
Az Egyes műveleteknél a jobb felső sarokban válassza a három pont (...) gombot, majd válassza a Gépház.
Az Egyidejűség-vezérlés csoportban állítsa be az egyidejűség-vezérlést Be é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 futtatási korlát 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-motor 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 nyomást az egyidejűség miatt. 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 100
terjedhet.
"<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 Logic Apps-Tervező, mert az egyidejűségi beállítás 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.
Megjegyzés:
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 operationOptions
Sequential
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 tulajdonságot a runtimeConfiguration.concurrency.runs
következőre 1
:
"<trigger-name>": {
"type": "<trigger-name>",
"recurrence": {
"frequency": "<time-unit>",
"interval": <number-of-time-units>,
},
"runtimeConfiguration": {
"concurrency": {
"runs": 1
}
}
}
-Vagy-
Állítsa a tulajdonságot a operationOptions
következőre 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 Logic Apps Tervező
Az eseményindító jobb felső sarkában válassza a három pont (...) gombot, majd válassza a Gépház.
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 számra
1
.
Futtassa az "egyes" hurkokat egymás után
Ha csak az előző iteráció futtatása után szeretne "mindegyikhez" ciklus-iterációt futtatni, állítsa az "egyes" műveletet egymás után futtatásra. Használhatja a kódnézet-szerkesztőt vagy a Logic Apps Tervező, 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.
Megjegyzés:
Ha az "egyes" műveletet egymás után futtatja a tervező vagy a kódnézet-szerkesztő használatával, ne állítsa be a művelet tulajdonságát operationOptions
Sequential
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 tulajdonságot a runtimeConfiguration.concurrency.repetitions
következőre 1
:
"For_each" {
"type": "Foreach",
"actions": { "<actions-to-run>" },
"foreach": "<for-each-expression>",
"runAfter": {},
"runtimeConfiguration": {
"concurrency": {
"repetitions": 1
}
}
}
-Vagy-
Állítsa a tulajdonságot a operationOptions
következőre 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 Logic Apps Tervező
Az egyes műveletek jobb felső sarkában válassza a három pont (...) gombot, majd válassza a Gépház.
Az Egyidejűség-vezérlés csoportban állítsa be az egyidejűség-vezérlést Be értékre.
Húzza a párhuzamosság foka csúszkát a számra
1
.
Műveletek futtatása szinkron műveleti mintában
Az Azure Logic Apps HTTP-művelete és API Csatlakozás ion-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 Logikai alkalmazás Tervező a HTTP-művelet, az API Csatlakozás ion-műveletek és a Válasz művelet aszinkron minta beá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:
A HTTP-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.
A művelet mögöttes JavaScript Object Notation (JSON) definíciójában a HTTP-művelet és az API Csatlakozás ionmű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 Logikai alkalmazás Tervező 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 Logikai alkalmazás Tervező 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.