Schemareferensguide för arbetsflödesdefinitionsspråket i Azure Logic Apps

Artikel
06/13/2024

När du skapar en logikapp i Azure Logic Apps har logikappen en underliggande arbetsflödesdefinition som beskriver den faktiska logik som körs i logikappen. Den arbetsflödesdefinitionen använder JSON och följer en struktur som verifieras av schemat arbetsflödesdefinitionsspråk. Den här referensen ger en översikt över den här strukturen och hur schemat definierar attribut i arbetsflödesdefinitionen.

Arbetsflödesdefinitionsstruktur

En arbetsflödesdefinition innehåller alltid en utlösare för instansiering av logikappen, plus en eller flera åtgärder som körs när utlösaren utlöses.

Här är den övergripande strukturen för en arbetsflödesdefinition:

"definition": {
  "$schema": "<workflow-definition-language-schema-version>",
  "actions": { "<workflow-action-definitions>" },
  "contentVersion": "<workflow-definition-version-number>",
  "outputs": { "<workflow-output-definitions>" },
  "parameters": { "<workflow-parameter-definitions>" },
  "staticResults": { "<static-results-definitions>" },
  "triggers": { "<workflow-trigger-definitions>" }
}

Attribut	Obligatoriskt	Beskrivning
`definition`	Ja	Startelementet för arbetsflödesdefinitionen
`$schema`	Endast när du refererar till en arbetsflödesdefinition externt	Platsen för JSON-schemafilen som beskriver versionen av arbetsflödesdefinitionsspråket, som du hittar här: `https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json`
`actions`	Nej	Definitionerna för en eller flera åtgärder som ska köras vid arbetsflödeskörning. Mer information finns i Utlösare och åtgärder. Maximalt antal åtgärder: 250
`contentVersion`	Nej	Versionsnumret för arbetsflödesdefinitionen, som är "1.0.0.0" som standard. Ange ett värde som ska användas för att identifiera och bekräfta rätt definition när du distribuerar ett arbetsflöde.
`outputs`	Nej	Definitionerna för utdata som ska returneras från en arbetsflödeskörning. Mer information finns i Utdata. Maximalt antal utdata: 10
`parameters`	Nej	Definitionerna för en eller flera parametrar som skickar de värden som ska användas vid logikappens körning. Mer information finns i Parametrar. Maximala parametrar: 50
`staticResults`	Nej	Definitionerna för ett eller flera statiska resultat som returneras av åtgärder som falska utdata när statiska resultat aktiveras för dessa åtgärder. I varje åtgärdsdefinition `runtimeConfiguration.staticResult.name` refererar attributet till motsvarande definition i `staticResults`. Mer information finns i Statiska resultat.
`triggers`	Nej	Definitionerna för en eller flera utlösare som instansierar arbetsflödet. Du kan definiera mer än en utlösare, men bara med arbetsflödesdefinitionsspråket, inte visuellt via arbetsflödesdesignern. Mer information finns i Utlösare och åtgärder. Maximalt antal utlösare: 10

Utlösare och åtgärder

I en arbetsflödesdefinition definierar avsnitten triggers och actions de anrop som inträffar under arbetsflödets körning. Syntax och mer information om dessa avsnitt finns i Arbetsflödesutlösare och åtgärder.

Parametrar

Distributionens livscykel har vanligtvis olika miljöer för utveckling, testning, mellanlagring och produktion. När du distribuerar logikappar till olika miljöer vill du förmodligen använda olika värden, till exempel niska veze, baserat på dina distributionsbehov. Eller så kan du ha värden som du vill återanvända i hela logikappen utan hårdkodning eller som ändras ofta. I avsnittet för arbetsflödesdefinitionen parameters kan du definiera eller redigera parametrar för de värden som logikappen använder vid körning. Du måste definiera dessa parametrar först innan du kan referera till dessa parametrar någon annanstans i arbetsflödesdefinitionen.

Här är den allmänna strukturen för en parameterdefinition:

"parameters": {
   "<parameter-name>": {
      "type": "<parameter-type>",
      "defaultValue": <default-parameter-value>,
      "allowedValues": [ <array-with-permitted-parameter-values> ],
      "metadata": {
         "description": "<parameter-description>"
      }
   }
},

Attribut	Obligatoriskt	Type	Beskrivning
<parameter-name>	Ja	String	Namnet på parametern som du vill definiera
<parametertyp>	Ja	int, float, string, bool, array, object, securestring, secureobject Obs! För alla lösenord, nycklar och hemligheter använder du typerna `securestring` eller `secureobject` eftersom åtgärden `GET` inte returnerar dessa typer. Mer information om hur du skyddar parametrar finns i Säkerhetsrekommendationer för åtgärds- och indataparametrar.	Typ för parametern
<default-parameter-value>	Ja	Samma som `type`	Standardparametervärdet som ska användas om inget värde anges när arbetsflödet instansierar. Attributet `defaultValue` krävs så att Logikappdesignern kan visa parametern korrekt, men du kan ange ett tomt värde.
<array-with-permitted-parameter-values>	Nej	Matris	En matris med värden som parametern kan acceptera
<parameterbeskrivning>	Nej	JSON-objekt	Annan parameterinformation, till exempel en beskrivning av parametern

Skapa sedan en Azure Resource Manager-mall för arbetsflödesdefinitionen, definiera mallparametrar som accepterar de värden du vill använda vid distributionen, ersätt hårdkodade värden med referenser till mall- eller arbetsflödesdefinitionsparametrar efter behov och lagra de värden som ska användas vid distributionen i en separat parameterfil. På så sätt kan du enkelt ändra dessa värden via parameterfilen utan att behöva uppdatera och distribuera om logikappen. För information som är känslig eller måste skyddas, till exempel användarnamn, lösenord och hemligheter, kan du lagra dessa värden i Azure Key Vault och låta parameterfilen hämta dessa värden från nyckelvalvet. Mer information och exempel om hur du definierar parametrar på mall- och arbetsflödesdefinitionsnivåer finns i Översikt: Automatisera distribution för logikappar med Azure Resource Manager-mallar.

Statiska resultat

staticResults I attributet definierar du en åtgärds mock outputs och status att åtgärden returnerar när åtgärdens statiska resultatinställning är aktiverad. I åtgärdens definition runtimeConfiguration.staticResult.name refererar attributet till namnet på den statiska resultatdefinitionen i staticResults. Lär dig hur du kan testa logikapparbetsflöden med falska data genom att konfigurera statiska resultat.

"definition": {
   "$schema": "<...>",
   "actions": { "<...>" },
   "contentVersion": "<...>",
   "outputs": { "<...>" },
   "parameters": { "<...>" },
   "staticResults": {
      "<static-result-definition-name>": {
         "outputs": {
            <output-attributes-and-values-returned>,
            "headers": { <header-values> },
            "statusCode": "<status-code-returned>"
         },
         "status": "<action-status>"
      }
   },
   "triggers": { "<...>" }
}

Attribut	Obligatoriskt	Type	Beskrivning
<static-result-definition-name>	Ja	String	Namnet på en statisk resultatdefinition som en åtgärdsdefinition kan referera till via ett `runtimeConfiguration.staticResult` objekt. Mer information finns i Konfigurationsinställningar för Körning. Du kan använda valfritt unikt namn. Som standard läggs det här unika namnet till med ett tal som ökas efter behov.
<output-attributes-and-values-returned>	Ja	Det varierar	Kraven för dessa attribut varierar beroende på olika villkor. När `status` är `Succeededoutputs` innehåller attributet till exempel attribut och värden som returneras som falska utdata av åtgärden. `status` Om är `Failedoutputs` innehåller `errors` attributet attributet, som är en matris med ett eller flera felobjekt `message` som har felinformation.
<header-values>	Nej	JSON	Alla rubrikvärden som returneras av åtgärden
<status-code-returned>	Ja	String	Statuskoden som returneras av åtgärden
<åtgärdsstatus>	Ja	String	Åtgärdens status, till exempel, `Succeeded` eller `Failed`

I den här HTTP-åtgärdsdefinitionen runtimeConfiguration.staticResult.name definieras till exempel attributreferenserna HTTP0 i staticResults attributet där mock-utdata för åtgärden definieras. Attributet runtimeConfiguration.staticResult.staticResultOptions anger att inställningen för statiskt resultat finns Enabled på HTTP-åtgärden.

"actions": {
   "HTTP": {
      "inputs": {
         "method": "GET",
         "uri": "https://www.microsoft.com"
      },
      "runAfter": {},
      "runtimeConfiguration": {
         "staticResult": {
            "name": "HTTP0",
            "staticResultOptions": "Enabled"
         }
      },
      "type": "Http"
   }
},

HTTP-åtgärden returnerar utdata i HTTP0 definitionen i staticResults. I det här exemplet för statuskoden är OKmock-utdata . För rubrikvärden är "Content-Type": "application/JSON"mock-utdata . För åtgärdens status är Succeededmock-utdata .

"definition": {
   "$schema": "<...>",
   "actions": { "<...>" },
   "contentVersion": "<...>",
   "outputs": { "<...>" },
   "parameters": { "<...>" },
   "staticResults": {
      "HTTP0": {
         "outputs": {
            "headers": {
               "Content-Type": "application/JSON"
            },
            "statusCode": "OK"
         },
         "status": "Succeeded"
      }
   },
   "triggers": { "<...>" }
},

Uttryck

Med JSON kan du ha literalvärden som finns vid designtillfället, till exempel:

"customerName": "Sophia Owen",
"rainbowColors": ["red", "orange", "yellow", "green", "blue", "indigo", "violet"],
"rainbowColorsCount": 7

Du kan också ha värden som inte finns förrän körningstiden. För att representera dessa värden kan du använda uttryck som utvärderas vid körning. Ett uttryck är en sekvens som kan innehålla en eller flera funktioner, operatorer, variabler, explicita värden eller konstanter. I arbetsflödesdefinitionen kan du använda ett uttryck var som helst i ett JSON-strängvärde genom att prefixa uttrycket med at-sign (@). När du utvärderar ett uttryck som representerar ett JSON-värde extraheras uttryckstexten genom att @-tecknet tas bort och resulterar alltid i ett annat JSON-värde.

För den tidigare definierade customerName egenskapen kan du till exempel hämta egenskapsvärdet med hjälp av funktionen parameters() i ett uttryck och tilldela värdet till accountName egenskapen:

"customerName": "Sophia Owen",
"accountName": "@parameters('customerName')"

Med stränginterpolation kan du också använda flera uttryck inuti strängar som omsluts av @-tecknet och klammerparenteser ({}). Här är syntaxen:

@{ "<expression1>", "<expression2>" }

Resultatet är alltid en sträng, vilket gör att den här funktionen liknar funktionen, till concat() exempel:

"customerName": "First name: @{parameters('firstName')} Last name: @{parameters('lastName')}"

Om du har en literalsträng som börjar med @-tecknet prefixar du @-tecknet med ett annat @-tecken som ett escape-tecken: @@

De här exemplen visar hur uttryck utvärderas:

JSON-värde	Result
"Sophia Owen"	Returnera dessa tecken: "Sophia Owen"
"matris[1]"	Returnera följande tecken: 'array[1]'
"@@"	Returnera dessa tecken som en sträng med ett tecken: '@'
" @"	Returnera dessa tecken som en sträng med två tecken: ' @'

I de här exemplen antar vi att du definierar "myBirthMonth" lika med "Januari" och "myAge" som är lika med talet 42:

"myBirthMonth": "January",
"myAge": 42

De här exemplen visar hur följande uttryck utvärderas:

JSON-uttryck	Result
"@parameters('myBirthMonth')"	Returnera den här strängen: "Januari"
"@{parameters('myBirthMonth')}"	Returnera den här strängen: "Januari"
"@parameters('myAge')"	Returnera det här numret: 42
"@{parameters('myAge')}"	Returnera det här talet som en sträng: "42"
"Min ålder är @{parameters('myAge')}"	Returnera den här strängen: "Min ålder är 42"
"@concat('My age is ', string(parameters('myAge')))"	Returnera den här strängen: "Min ålder är 42"
"Min ålder är @@{parameters('myAge')}"	Returnera den här strängen, som innehåller uttrycket : "Min ålder är @{parameters('myAge')}'

När du arbetar visuellt i arbetsflödesdesignern kan du skapa uttryck med hjälp av uttrycksredigeraren, till exempel:

Skärmbild som visar arbetsflödesdesignern och uttrycksredigeraren.

När du är klar visas uttrycket för motsvarande egenskap i arbetsflödesdefinitionen searchQuery , till exempel egenskapen här:

"Search_tweets": {
  "inputs": {
    "host": {
      "connection": {
        "name": "@parameters('$connections')['x']['connectionId']"
      }
    }
  },
  "method": "get",
  "path": "/searchtweets",
  "queries": {
    "maxResults": 20,
    "searchQuery": "Azure @{concat('firstName','', 'LastName')}"
  }
},

Utdata

I avsnittet outputs definierar du de data som arbetsflödet kan returnera när du är klar med körningen. Om du till exempel vill spåra en specifik status eller ett visst värde från varje körning anger du att arbetsflödets utdata returnerar dessa data.

Kommentar

När du svarar på inkommande begäranden från en tjänsts REST-API ska du inte använda outputs. Använd i stället åtgärdstypen Response . Mer information finns i Arbetsflödesutlösare och åtgärder.

Här är den allmänna strukturen för en utdatadefinition:

"outputs": {
  "<key-name>": {
    "type": "<key-type>",
    "value": "<key-value>"
  }
}

Attribut	Obligatoriskt	Type	Beskrivning
<nyckelnamn>	Ja	String	Nyckelnamnet för returvärdet för utdata
<nyckeltyp>	Ja	int, float, string, securestring, bool, array, JSON object	Typ för returvärdet för utdata
<nyckelvärde>	Ja	Samma som <nyckeltyp>	Returvärdet för utdata

Om du vill hämta utdata från en arbetsflödeskörning läser du logikappens körningshistorik och information i Azure-portalen eller använder REST API för arbetsflöde. Du kan också skicka utdata till externa system, till exempel Power BI så att du kan skapa instrumentpaneler.

Operatorer

I uttryck och funktioner utför operatorerna specifika uppgifter, till exempel referens till en egenskap eller ett värde i en matris.

Operator	Uppgift
`'`	Om du vill använda en strängliteral som indata eller i uttryck och funktioner omsluter du strängen endast med enkla citattecken, `'<myString>'`till exempel . Använd inte dubbla citattecken (`""`), som står i konflikt med JSON-formateringen runt ett helt uttryck. Till exempel: Ja: length('Hello') No: length("Hello") När du skickar matriser eller siffror behöver du inte omsluta skiljetecken. Till exempel: Ja: längd([1, 2, 3]) Nej: längd("[1, 2, 3]")
`[]`	Om du vill referera till ett värde vid en specifik position (index) i en matris eller inuti ett JSON-objekt använder du hakparenteser, till exempel: – Så här hämtar du det andra objektet i en matris: `myArray[1]` – Så här kommer du åt egenskaperna i ett JSON-objekt: Exempel 1: `setProperty(<object>, '<parent-property>', addProperty(<object>['<parent-property>'], '<child-property>', <value>)` Exempel 2: `lastIndexOf(triggerBody()?['subject'],'some string')`
`.`	Om du vill referera till en egenskap i ett objekt använder du punktoperatorn. Om du till exempel vill hämta `name` egenskapen för ett `customer` JSON-objekt: `"parameters('customer').name"`
`?`	Om du vill referera till null-egenskaper i ett objekt utan körningsfel använder du operatorn null-ignore (?). Om du till exempel vill hantera null-utdata från en utlösare kan du använda följande uttryck: `coalesce(trigger().outputs?.body?['<someProperty>'], '<property-default-value>')`

Functions

Vissa uttryck får sina värden från körningsåtgärder som kanske inte finns ännu när arbetsflödesdefinitionen börjar köras. Om du vill referera till eller arbeta med dessa värden i uttryck kan du använda funktioner som arbetsflödesdefinitionsspråket tillhandahåller.

Nästa steg

Läs mer om åtgärder och utlösare för arbetsflödesdefinitionsspråk
Lär dig mer om att programmatiskt skapa och hantera logikappar med REST API för arbetsflöde

Dela via