Creare, modificare o personalizzare JSON per le definizioni di app per la logicaCreate, edit, or customize JSON for logic app definitions

Quando si creano soluzioni di integrazione a livello aziendale con flussi di lavoro automatizzati in App per la logica di Azure, le definizioni di app per la logica sottostanti usano il semplice linguaggio dichiarativo JSON (JavaScript Object Notation) insieme allo schema del linguaggio di definizione del flusso di lavoro per la descrizione e la convalida.When you create enterprise integration solutions with automated workflows in Azure Logic Apps, the underlying logic app definitions use simple and declarative JavaScript Object Notation (JSON) along with the Workflow Definition Language (WDL) schema for their description and validation. Questi formati rendono le definizioni di app per la logica più semplici da leggere e da comprendere, senza dover necessariamente avere familiarità con il codice.These formats make logic app definitions easier to read and understand without knowing much about code. Quando si vuole automatizzare la creazione e la distribuzione di app per la logica, è possibile includere le definizioni di app per la logica come risorse di Azure all'interno di modelli di Azure Resource Manager.When you want to automate creating and deploying logic apps, you can include logic app definitions as Azure resources inside Azure Resource Manager templates. Per creare, gestire e distribuire app per la logica, è quindi possibile usare Azure PowerShell, l'interfaccia della riga di comando di Azure o le API REST di App per la logica di Azure.To create, manage, and deploy logic apps, you can then use Azure PowerShell, Azure CLI, or the Azure Logic Apps REST APIs.

Per usare le definizioni di app per la logica in JSON, aprire l'editor della visualizzazione Codice quando si lavora nel portale di Azure o in Visual Studio oppure copiare la definizione nell'editor che si preferisce.To work with logic app definitions in JSON, open the Code View editor when working in the Azure portal or in Visual Studio, or copy the definition into any editor that you want. Se non si ha familiarità con le app per la logica, vedere come creare la prima app per la logica.If you're new to logic apps, review how to create your first logic app.

Nota

Alcune funzionalità di App per la logica di Azure, ad esempio la definizione di parametri e di più trigger nelle definizioni di app per la logica, sono disponibili solo in JSON e non in Progettazione app per la logica.Some Azure Logic Apps capabilities, such as defining parameters and multiple triggers in logic app definitions, are available only in JSON, not the Logic Apps Designer. Pertanto, per queste attività è necessario lavorare nella visualizzazione Codice o in un altro editor.So for these tasks, you must work in Code View or another editor.

Modificare JSON - Portale di AzureEdit JSON - Azure portal

  1. Accedere al portale di Azure.Sign in to the Azure portal.

  2. Dal menu a sinistra scegliere Tutti i servizi.From the left menu, choose All services. Nella casella di ricerca cercare "app per la logica" e quindi selezionare l'app per la logica desiderata nei risultati.In the search box, find "logic apps", and then from the results, select your logic app.

  3. Nel menu dell'app per la logica, in Strumenti di sviluppo selezionare Visualizzazione codice app per la logica.On your logic app's menu, under Development Tools, select Logic App Code View.

    L'editor della visualizzazione Codice si apre e mostra la definizione dell'app per la logica in formato JSON.The Code View editor opens and shows your logic app definition in JSON format.

Modificare JSON - Visual StudioEdit JSON - Visual Studio

Prima di usare la definizione dell'app per logica in Visual Studio, assicurarsi di avere installato gli strumenti richiesti.Before you can work on your logic app definition in Visual Studio, make sure that you've installed the required tools. Per creare un'app per la logica con Visual Studio, vedere Quickstart: Automate tasks and processes with Azure Logic Apps - Visual Studio (Guida introduttiva: Automatizzare attività e processi con App per la logica di Azure - Visual Studio).To create a logic app with Visual Studio, review Quickstart: Automate tasks and processes with Azure Logic Apps - Visual Studio.

In Visual Studio è possibile aprire le app per la logica che sono state create e distribuite direttamente dal portale di Azure o come progetti di Azure Resource Manager da Visual Studio.In Visual Studio, you can open logic apps that were created and deployed either directly from the Azure portal or as Azure Resource Manager projects from Visual Studio.

  1. Aprire la soluzione di Visual Studio o il progetto del gruppo di risorse di Azure contenente l'app per la logica.Open the Visual Studio solution, or Azure Resource Group project, that contains your logic app.

  2. Individuare e aprire la definizione dell'app per la logica, che per impostazione predefinita viene visualizzata in un modello di Resource Manager, denominato LogicApp.json.Find and open your logic app's definition, which by default, appears in an Resource Manager template, named LogicApp.json. È possibile usare e personalizzare questo modello per la distribuzione in ambienti diversi.You can use and customize this template for deployment to different environments.

  3. Aprire il menu di scelta rapida per la definizione e il modello dell'app per la logica.Open the shortcut menu for your logic app definition and template. Selezionare Open With Logic App Designer (Apri con Progettazione app per la logica).Select Open With Logic App Designer.

    Aprire un'app per la logica in una soluzione di Visual Studio

  4. Nella parte inferiore della finestra di progettazione scegliere Visualizzazione Codice.At the bottom of the designer, choose Code View.

    L'editor della visualizzazione Codice si apre e mostra la definizione dell'app per la logica in formato JSON.The Code View editor opens and shows your logic app definition in JSON format.

  5. Per tornare alla visualizzazione della finestra di progettazione, nella parte inferiore dell'editor della visualizzazione Codice, scegliere Progettazione.To return to designer view, at the bottom of the Code View editor, choose Design.

ParametriParameters

I parametri consentono di riutilizzare i valori in tutta l'app per la logica e sono ideali per la sostituzione dei valori che si potrebbero modificare spesso.Parameters let you reuse values throughout your logic app and are good for replacing values that you might change often. Se ad esempio si ha un indirizzo di posta elettronica che si vuole usare in più posizioni, è consigliabile definirlo come parametro.For example, if you have an email address that you want use in multiple places, you should define that email address as a parameter.

I parametri sono utili anche quando è necessario eseguire l'override dei parametri in ambienti diversi. Per altre informazioni, vedere i parametri per la distribuzione e la documentazione sull'API REST per App per la logica di Azure.Parameters are also useful when you need to override parameters in different environments, Learn more about parameters for deployment and the REST API for Azure Logic Apps documentation.

Nota

I parametri sono disponibili solo nella visualizzazione Codice.Parameters are only available in code view.

Nella prima app per la logica di esempio è stato creato un flusso di lavoro che invia messaggi di posta elettronica quando vengono visualizzati nuovi post nel feed RSS di un sito Web.In the first example logic app, you created a workflow that sends emails when new posts appear in a website's RSS feed. L'URL del feed è hardcoded, quindi questo esempio illustra come sostituire il valore della query con un parametro per poter modificare più facilmente l'URL del feed.The feed's URL is hardcoded, so this example shows how to replace the query value with a parameter so that you can change feed's URL more easily.

  1. Nella visualizzazione codice trovare l'oggetto parameters : {} e aggiungere un oggetto currentFeedUrl:In code view, find the parameters : {} object, and add a currentFeedUrl object:

      "currentFeedUrl" : {
       "type" : "string",
             "defaultValue" : "http://rss.cnn.com/rss/cnn_topstories.rss"
    }
    
  2. Nell'azione When_a_feed-item_is_published trovare la sezione queries e sostituire il valore della query con "feedUrl": "#@{parameters('currentFeedUrl')}".In the When_a_feed-item_is_published action, find the queries section, and replace the query value with "feedUrl": "#@{parameters('currentFeedUrl')}".

    PrimaBefore

    }
       "queries": {
           "feedUrl": "https://s.ch9.ms/Feeds/RSS"
        }
    },   
    

    DopoAfter

    }
       "queries": {
           "feedUrl": "#@{parameters('currentFeedUrl')}"
        }
    },   
    

    Per unire due o più stringhe, è inoltre possibile usare la funzione concat.To join two or more strings, you can also use the concat function. Ad esempio, "@concat('#',parameters('currentFeedUrl'))" funziona come l'esempio precedente.For example, "@concat('#',parameters('currentFeedUrl'))" works the same as the previous example.

  3. Al termine dell'operazione, scegliere Salva.When you're done, choose Save.

Ora è possibile modificare il feed RSS del sito Web passando un URL diverso attraverso l'oggetto currentFeedURL.Now you can change the website's RSS feed by passing a different URL through the currentFeedURL object.

Parametri di distribuzione per diversi ambientiDeployment parameters for different environments

I cicli di vita delle distribuzioni hanno in genere ambienti per lo sviluppo, lo staging e la produzione.Usually, deployment lifecycles have environments for development, staging, and production. È possibile, ad esempio, usare la stessa definizione di app per la logica in tutti questi ambienti, ma usare database diversi.For example, you might use the same logic app 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 usi 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 use that region's database.

Nota

Questo scenario è diverso da quello in cui si accettano i parametri in fase di esecuzione, dove è consigliabile usare invece la funzione trigger().This scenario differs from taking parameters at runtime where you should use the trigger() function instead.

Di seguito è riportata una definizione di base:Here's a basic definition:

{
    "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.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. 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. 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"
}

Per altre informazioni, vedere la documentazione sull'API REST per App per la logica di Azure.To learn more, see the REST API for Azure Logic Apps documentation.

Elaborare le stringhe con le funzioniProcess strings with functions

App per la logica ha diverse funzioni per l'uso delle stringhe.Logic Apps has various functions for working with strings. Si supponga, ad esempio, di voler passare un nome di società da un ordine a un altro sistema.For example, suppose you want to pass a company name from an order to another system. Tuttavia, non si è certi di come gestire correttamente la codifica dei caratteri.However, you're not sure about proper handling for character encoding. Si potrebbe eseguire la codifica Base 64 su questa stringa, ma, per evitare caratteri di escape nell'URL, è invece possibile sostituire alcuni caratteri.You could perform base64 encoding on this string, but to avoid escapes in the URL, you can replace several characters instead. È inoltre necessario ottenere solo una sottostringa del nome della società, perché i primi cinque caratteri non vengono usati.Also, you only need a substring for the company name because the first five characters are not used.

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder1",
        "companyName": "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').companyName,5,sub(length(parameters('order').companyName), 5) )),'+','-') ,'/' ,'_' )}"
      }
    }
  },
  "outputs": {}
}

I passaggi seguenti descrivono come questa stringa viene elaborata nell'esempio, a partire dall'interno verso l'esterno:These steps describe how this example processes this string, working from the inside to the outside:

"uri": "http://www.example.com/?id=@{replace(replace(base64(substring(parameters('order').companyName,5,sub(length(parameters('order').companyName), 5) )),'+','-') ,'/' ,'_' )}"
  1. Ottenere l'elemento length() per il nome della società per poter ottenere il numero totale di caratteri.Get the length() for the company name, so you get the total number of characters.

  2. Per ottenere una stringa più breve, sottrarre 5.To get a shorter string, subtract 5.

  3. Ottenere ora substring().Now get a substring(). Iniziare dall'indice 5 e procedere alla parte rimanente della stringa.Start at index 5, and go to the remainder of the string.

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

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

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

Eseguire il mapping degli elementi di elenco ai valori delle proprietà, quindi usare le mappe come parametriMap list items to property values, then use maps as parameters

Per ottenere risultati diversi in base al valore di una proprietà, è possibile creare una mappa che associa ogni valore della proprietà a un risultato, quindi usare tale mappa come parametro.To get different results based a property's value, you can create a map that matches each property value to a result, then use that map as a parameter.

Questo flusso di lavoro, ad esempio, definisce alcune categorie come parametri e una mappa che associa tali categorie a un URL specifico.For example, this workflow defines some categories as parameters and a map that matches those categories with a specific URL. Il flusso di lavoro ottiene prima di tutto un elenco degli articoli,First, the workflow gets a list of articles. quindi usa la mappa per trovare l'URL corrispondente alla categoria per ogni articolo.Then, the workflow uses the map to find the URL matching the category for each article.

  • La funzione intersection() controlla se la categoria corrisponde a una categorie nota definita.The intersection() function checks whether the category matches a known defined category.

  • Dopo avere ottenuto una categoria corrispondente, l'esempio esegue il pull dell'elemento dalla mappa usando le parentesi quadre: parameters[...]After getting a matching category, the example pulls the item from the map using square brackets: parameters[...]

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.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"
        ]
      }
    }
  }
}

Ottenere i dati con le funzioni di dataGet data with Date functions

Per ottenere i dati da un'origine dati che non supporta i trigger in modo nativo, è possibile usare le funzioni di data per lavorare invece con ore e date.To get data from a data source that doesn't natively support triggers, you can use Date functions for working with times and dates instead. Questa espressione, ad esempio, trova quanto tempo richiedono i passaggi di questo flusso di lavoro, procedendo dall'interno verso l'esterno:For example, this expression finds how long this workflow's steps are taking, working from the inside to the outside:

"expression": "@less(actions('order').startTime,addseconds(utcNow(),-1))",
  1. Dall'azione order estrarre startTime.From the order action, extract the startTime.
  2. Ottenere l'ora corrente con utcNow().Get the current time with utcNow().
  3. Sottrarre un secondo: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.

  4. È ora possibile confrontare questi due valori.Now, you 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, you can use string formatters. Per ottenere la specifica RFC1123, ad esempio, usare utcnow('r').For example, to get the RFC1123, use utcnow('r'). Altre informazioni sulla formattazione delle date.Learn more about date formatting.

{
  "$schema": "https://schema.management.azure.com/schemas/2016-06-01/Microsoft.Logic.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "order": {
      "defaultValue": {
        "quantity": 10,
        "id": "myorder-id"
      },
      "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": {}
}

Passaggi successiviNext steps