Creare definizioni dei flussi di lavoro per le app per la logica usando JSONCreate workflow definitions for logic apps using JSON

È possibile creare definizioni flusso di lavoro per App per la logica di Azure con il semplice linguaggio dichiarativo JSON.You can create workflow definitions for Azure Logic Apps with simple, declarative JSON language. Se non è già stato fatto, vedere prima come creare la prima app per la logica con Progettazione app per la logica.If you haven't already, first review how to create your first logic app with Logic App Designer. Vedere anche le informazioni di riferimento complete per il linguaggio di definizione del flusso di lavoro.Also, see the full reference for the Workflow Definition Language.

Ripetere i passaggi in un elencoRepeat steps over a list

Per eseguire l'iterazione in una matrice con più di 10.000 elementi ed eseguire un'azione per ogni elemento, usare il tipo foreach.To iterate through an array that has up to 10,000 items and perform an action for each item, use the foreach type.

Gestire gli errori in caso di problemiHandle failures if something goes wrong

In genere, è opportuno includere una procedura di correzione, ovvero la logica che viene eseguita se e solo se una o più chiamate hanno esito negativo.Usually, you want to include a remediation step — some logic that executes if and only if one or more of your calls fail. Questo esempio recupera i dati da diverse posizioni, ma, se la chiamata ha esito negativo, è opportuno INSERIRE un messaggio in un punto qualsiasi, per poter ricostruire l'errore in un secondo momento:This example gets data from various places, but if the call fails, we want to POST a message somewhere so we can track down that failure later:

{
  "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {},
  "triggers": {
    "Request": {
      "type": "request",
      "kind": "http"
    }
  },
  "actions": {
    "readData": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      }
    },
    "postToErrorMessageQueue": {
      "type": "ApiConnection",
      "inputs": "...",
      "runAfter": {
        "readData": [
          "Failed"
        ]
      }
    }
  },
  "outputs": {}
}

Per specificare che postToErrorMessageQueue viene eseguito solo quando readData è Failed, usare la proprietà runAfter, ad esempio, per specificare un elenco di possibili valori, in modo che runAfter possa essere ["Succeeded", "Failed"].To specify that postToErrorMessageQueue only runs after readData has Failed, use the runAfter property, for example, to specify a list of possible values, so that runAfter could be ["Succeeded", "Failed"].

Infine, poiché questo esempio ora gestisce l'errore, l'esecuzione non viene più contrassegnata come Failed.Finally, because this example now handles the error, we no longer mark the run as Failed. Poiché è stato aggiunto il passaggio per gestire questo errore nell'esempio, l'esecuzione è Succeeded anche se un passaggio è Failed.Because we added the step for handling this failure in this example, the run has Succeeded although one step Failed.

Eseguire due o più passaggi in paralleloExecute two or more steps in parallel

Per eseguire più azioni in parallelo, la proprietà runAfter deve essere equivalente in fase di esecuzione.To run multiple actions in parallel, the runAfter property must be equivalent at runtime.

{
  "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {},
  "triggers": {
    "Request": {
      "kind": "http",
      "type": "Request"
    }
  },
  "actions": {
    "readData": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      }
    },
    "branch1": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      },
      "runAfter": {
        "readData": [
          "Succeeded"
        ]
      }
    },
    "branch2": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      },
      "runAfter": {
        "readData": [
          "Succeeded"
        ]
      }
    }
  },
  "outputs": {}
}

In questo esempio sia branch1 che branch2 vengono impostati per l'esecuzione dopo readData.In this example, both branch1 and branch2 are set to run after readData. Di conseguenza, entrambi i rami vengono eseguiti in parallelo.As a result, both branches run in parallel. Il timestamp è identico per entrambi i rami.The timestamp for both branches is identical.

Parallelo

Creare un join di due rami paralleliJoin two parallel branches

È possibile creare un join di due azioni impostate per l'esecuzione in parallelo aggiungendo elementi alla proprietà runAfter come nell'esempio precedente.You can join two actions that are set to run in parallel by adding items to the runAfter property as in the previous example.

{
  "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-04-01-preview/workflowdefinition.json#",
  "actions": {
    "readData": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      },
      "runAfter": {}
    },
    "branch1": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      },
      "runAfter": {
        "readData": [
          "Succeeded"
        ]
      }
    },
    "branch2": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      },
      "runAfter": {
        "readData": [
          "Succeeded"
        ]
      }
    },
    "join": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://myurl"
      },
      "runAfter": {
        "branch1": [
          "Succeeded"
        ],
        "branch2": [
          "Succeeded"
        ]
      }
    }
  },
  "parameters": {},
  "triggers": {
    "Request": {
      "type": "Request",
      "kind": "Http",
      "inputs": {
        "schema": {}
      }
    }
  },
  "contentVersion": "1.0.0.0",
  "outputs": {}
}

Parallelo

Eseguire il mapping di elementi elenco a una configurazione diversaMap list items to a different configuration

A questo punto, si vuole ottenere un contenuto diverso in base al valore di una proprietà.Next, let's say that we want to get different content based on the value of a property. È possibile creare una mappa di valori alle relative destinazioni come parametro.We can create a map of values to destinations as a parameter:

{
  "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "specialCategories": {
      "defaultValue": [
        "science",
        "google",
        "microsoft",
        "robots",
        "NSA"
      ],
      "type": "Array"
    },
    "destinationMap": {
      "defaultValue": {
        "science": "http://www.nasa.gov",
        "microsoft": "https://www.microsoft.com/en-us/default.aspx",
        "google": "https://www.google.com",
        "robots": "https://en.wikipedia.org/wiki/Robot",
        "NSA": "https://www.nsa.gov/"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "Request": {
      "type": "Request",
      "kind": "http"
    }
  },
  "actions": {
    "getArticles": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "https://ajax.googleapis.com/ajax/services/feed/load?v=1.0&q=http://feeds.wired.com/wired/index"
      }
    },
    "forEachArticle": {
      "type": "foreach",
      "foreach": "@body('getArticles').responseData.feed.entries",
      "actions": {
        "ifGreater": {
          "type": "if",
          "expression": "@greater(length(intersection(item().categories, parameters('specialCategories'))), 0)",
          "actions": {
            "getSpecialPage": {
              "type": "Http",
              "inputs": {
                "method": "GET",
                "uri": "@parameters('destinationMap')[first(intersection(item().categories, parameters('specialCategories')))]"
              }
            }
          }
        }
      },
      "runAfter": {
        "getArticles": [
          "Succeeded"
        ]
      }
    }
  }
}

In questo caso, si ottiene prima un elenco di articoli.In this case, we first get a list of articles. In base alla categoria definita come parametro, il secondo passaggio usa una mappa per cercare l'URL e ottenere così il contenuto.Based on the category that was defined as a parameter, the second step uses a map to look up the URL for getting the content.

Tenere presente quanto segue:Some times to note here:

  • La funzione intersection() controlla se la categoria corrisponde a una delle categorie note definite.The intersection() function checks whether the category matches one of the known defined categories.

  • Dopo avere ottenuto la categoria, è possibile effettuare il pull dell'elemento dalla mappa usando parentesi quadre: parameters[...].After we get the category, we can pull the item from the map using square brackets: parameters[...]

Elaborare le stringheProcess strings

È possibile usare svariate funzioni per modificare le stringhe.You can use various functions to manipulate strings. Si supponga, ad esempio, di avere una stringa che si vuole passare a un sistema, ma non si è certi di quale sia la gestione appropriata per la codifica dei caratteri.For example, suppose we have a string that we want to pass to a system, but we aren't confident about proper handling for character encoding. Per questa stringa è possibile usare, ad esempio, la codifica Base64.One option is to base64 encode this string. Tuttavia, per evitare di eseguire l'escape in un URL, verranno sostituiti alcuni caratteri.However, to avoid escaping in a URL, we are going to replace a few characters.

Si vuole anche ottenere una sottostringa del nome dell'ordine, perché i primi cinque caratteri non vengono usati.We also want a substring of the order's name because the first five characters are not used.

{
  "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder1",
        "orderer": "NAME=Contoso"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "request": {
      "type": "request",
      "kind": "http"
    }
  },
  "actions": {
    "order": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://www.example.com/?id=@{replace(replace(base64(substring(parameters('order').orderer,5,sub(length(parameters('order').orderer), 5) )),'+','-') ,'/' ,'_' )}"
      }
    }
  },
  "outputs": {}
}

Passaggio dall'interno all'esterno:Working from inside to outside:

  1. Ottenere l'elemento length() per il nome dell'autore dell'ordine per poter tornare al numero totale di caratteri.Get the length() for the orderer's name, so we get back the total number of characters.

  2. Sottrarre 5 perché si vuole ottenere una stringa più breve.Subtract 5 because we want a shorter string.

  3. Accettare di fatto l'elemento substring() .Actually, take the substring(). Inizia dall'indice 5 e procede alla parte rimanente della stringa.We start at index 5 and go the remainder of the string.

  4. Convertire la sottostringa in una stringa base64().Convert this substring to a base64() string.

  5. replace() sostituisce tutti i caratteri + con caratteri -.replace() all the + characters with - characters.

  6. replace() sostituisce tutti i caratteri / con caratteri _.replace() all the / characters with _ characters.

Uso di date e oreWork with Date Times

Date e ore possono risultare utili, specialmente quando si prova a effettuare il pull dei dati da un'origine dati che non supporta trigger in modo naturale.Date Times can be useful, particularly when you are trying to pull data from a data source that doesn't naturally support triggers. È anche possibile usare date e ore per trovare la durata di diversi passaggi.You can also use Date Times for finding how long various steps are taking.

{
  "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder1"
      },
      "type": "Object"
    }
  },
  "triggers": {
    "Request": {
      "type": "request",
      "kind": "http"
    }
  },
  "actions": {
    "order": {
      "type": "Http",
      "inputs": {
        "method": "GET",
        "uri": "http://www.example.com/?id=@{parameters('order').id}"
      }
    },
    "ifTimingWarning": {
      "type": "If",
      "expression": "@less(actions('order').startTime,addseconds(utcNow(),-1))",
      "actions": {
        "timingWarning": {
          "type": "Http",
          "inputs": {
            "method": "GET",
            "uri": "http://www.example.com/?recordLongOrderTime=@{parameters('order').id}&currentTime=@{utcNow('r')}"
          }
        }
      },
      "runAfter": {
        "order": [
          "Succeeded"
        ]
      }
    }
  },
  "outputs": {}
}

In questo esempio viene estratto l'elemento startTime dal passaggio precedente.In this example, we extract the startTime from the previous step. Si ottiene quindi l'ora corrente e si sottrae un secondo:Then we get the current time, and subtract one second:

addseconds(..., -1)

È possibile usare altre unità di tempo, ad esempio minutes o hours.You can use other units of time, like minutes or hours. Infine si potranno confrontare questi due valori.Finally, we can compare these two values. Se il primo valore è minore del secondo valore, è trascorso più di un secondo dal momento in cui è stato inserito l'ordine.If the first value is less than the second value, then more than one second has passed since the order was first placed.

Per formattare le date, è possibile usare formattatori di stringa.To format dates, we can use string formatters. Per ottenere la specifica RFC1123, ad esempio, si usa utcnow('r').For example, to get the RFC1123, we use utcnow('r'). Per informazioni sulla formattazione delle date, vedere Workflow Definition Language (Linguaggio di definizione del flusso di lavoro).To learn about date formatting, see Workflow Definition Language.

Parametri di distribuzione per diversi ambientiDeployment parameters for different environments

In genere, i cicli di vita di distribuzione prevedono un ambiente di sviluppo, un ambiente di staging e un ambiente di produzione.Commonly, deployment lifecycles have a development environment, a staging environment, and a production environment. È possibile, ad esempio, usare la stessa definizione in tutti questi ambienti, ma usare database diversi.For example, you might use the same definition in all these environments but use different databases. In modo analogo, è possibile usare la stessa definizione in aree diverse ai fini della disponibilità elevata, ma fare in modo che ogni istanza dell'app per la logica comunichi con il database di quell'area.Likewise, you might want to use the same definition across different regions for high availability but want each logic app instance to talk to that region's database. Questo scenario è diverso da quello in cui si accettano i parametri in fase di esecuzione, dove invece è consigliabile usare la funzione trigger() come nell'esempio precedente.This scenario differs from taking parameters at runtime where instead, you should use the trigger() function as in the previous example.

È possibile iniziare con una definizione di base, come questo esempio:You can start with a basic definition like this example:

{
    "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "uri": {
            "type": "string"
        }
    },
    "triggers": {
        "request": {
          "type": "request",
          "kind": "http"
        }
    },
    "actions": {
        "readData": {
            "type": "Http",
            "inputs": {
                "method": "GET",
                "uri": "@parameters('uri')"
            }
        }
    },
    "outputs": {}
}

Nella richiesta PUT effettiva per le app per la logica è possibile fornire il parametro uri.In the actual PUT request for the logic apps, you can provide the parameter uri. Poiché non esiste più un valore predefinito, il payload delle app per la logica richiede questo parametro:Because a default value no longer exists, the logic app payload requires this parameter:

{
    "properties": {},
        "definition": {
          // Use the definition from above here
        },
        "parameters": {
            "connection": {
                "value": "https://my.connection.that.is.per.enviornment"
            }
        }
    },
    "location": "westus"
}

In ogni ambiente è possibile fornire un valore diverso per il parametro connection.In each environment, you can provide a different value for the connection parameter.

Per tutte le opzioni disponibili per la creazione e la gestione di app per la logica, vedere documentazione dell'API REST.For all the options that you have for creating and managing logic apps, see the REST API documentation.