Creare un progetto del motore di regole di Azure Logic Apps con Visual Studio Code

Si applica: Azure Logic Apps (Standard)

Quando si vuole integrare la logica di business con i flussi di lavoro standard in Azure Logic Apps, è possibile creare e sviluppare un progetto di motore di regole di Azure Logic Apps utilizzando Visual Studio Code. Le regole regolano la logica di business per il funzionamento dei processi aziendali.

Questa guida illustra come creare un progetto del motore di regole per le app logiche di Azure.

Prerequisiti e configurazione per la creazione del progetto motore di regole di Azure Logic Apps, inclusa la creazione delle regole aziendali per il progetto con Microsoft Rules Composer.
Esportare le regole esistenti da Microsoft BizTalk Server, se presenti.
Creare un progetto Logic Apps Standard per il motore di regole di Azure Logic Apps usando Visual Studio Code.

Prerequisiti

Scaricare e installare Microsoft Rules Composer, usato per creare set di regole, regole business e vocabolari.

Per creare l'ambiente per il progetto del motore delle regole, vedere la documentazione seguente:
- Creare regole con Microsoft Rules Composer
- Gestione delle decisioni e integrazione della logica di business tramite il motore delle regole di Azure Logic Apps
Per questa versione, solo Visual Studio Code supporta l'esperienza di sviluppo per un progetto del motore di regole di Azure Logic Apps. Per soddisfare i prerequisiti per l'uso di Visual Studio Code, vedere Creare un flusso di lavoro di app per la logica standard in App per la logica di Azure a tenant singolo con Visual Studio Code.
Il motore delle regole di Azure Logic Apps utilizza la funzionalità di funzione di codice personalizzata in Visual Studio Code. Per soddisfare i prerequisiti per l'uso di questa funzionalità, vedere Creare ed eseguire codice .NET Framework dai flussi di lavoro Standard in App per la logica di Azure.

Prima di creare il progetto

Per aiutarti a garantire il successo di un progetto del motore di regole, esamina ed esegui le seguenti attività generali e best practice:

Determinare il modo in cui le regole business rientrano nei processi aziendali.
Pianificare come incorporare regole business nell'applicazione.
Identificare la logica di business che si vuole rappresentare con le regole nell'applicazione.

Il termine "logica di business" può fare riferimento a molte cose. Ad esempio, la logica di business potrebbe essere "Gli ordini di acquisto maggiori di 500 dollari richiedono l'approvazione del manager".
Identificare le fonti di dati per gli elementi della regola. Facoltativamente, è possibile definire i vocabolari, ovvero la denominazione specifica del dominio che rappresenta le associazioni sottostanti.
Definire le regole da usare dalle definizioni del vocabolario o direttamente dai data binding. Da queste regole creare un set di regole che rappresenta la logica di business.

Esportare regole da Microsoft BizTalk Server

Per riutilizzare le regole esistenti da Microsoft BizTalk Server, è possibile esportarle. Tuttavia, i dati del database non sono attualmente supportati. Prima di esportare le regole, rimuoverle o effettuare il refactoring in altri tipi di fatti usando Microsoft BizTalk Rules Composer.

Da Microsoft BizTalk Server, avvia la Creazione guidata di distribuzione del Motore Regole di Business.
Nella pagina di benvenuto alla procedura guidata di distribuzione del Motore Regole, selezionare Avanti.
Nella pagina Attività di distribuzione selezionare Esporta criteri/vocabolario nel file dal database e selezionare Avanti.
Nella pagina Archivio criteri, nell'elenco Nome SQL Server, selezionare il proprio SQL server. Nell'elenco Database di configurazione nel server selezionato selezionare BizTalkRuleEngineDb e quindi selezionare Avanti.
Nella pagina Esporta criteri/vocabolario selezionare i criteri desiderati dall'elenco Criteri. Per trovare e scegliere il file di definizione, selezionare Sfoglia.
Al termine, selezionare Avanti.
Confermare le informazioni sul server, il database e i criteri o sul vocabolario e selezionare Avanti.
Al termine dell'importazione o dell'esportazione, selezionare Avanti.
Esaminare lo stato di completamento per l'importazione o l'esportazione e selezionare Fine.

Creare un progetto motore di regole per Azure Logic Apps

Nella barra delle attività di Visual Studio Code selezionare l'icona di Azure. (Tastiera: MAIUSC+ALT+A)
Nella finestra di Azure visualizzata, sulla barra degli strumenti della sezione Area di lavoro, dal menu App per la logica di Azure, scegliere Crea nuova area di lavoro per l'app per la logica.
Nella casella Seleziona cartella, passare a e selezionare la cartella locale creata per il progetto.
Quando viene visualizzata la casella di richiesta Crea nuova area di lavoro per l'app per la logica, specificare un nome per l'area di lavoro:

Questo esempio continua con MyLogicAppRulesWorkspace.
Quando viene visualizzata la casella di richiesta Selezionare un modello di progetto per l'area di lavoro dell'app logica, selezionare progetto app logica con motore di regole.

Seguire le istruzioni successive per specificare i valori di esempio seguenti:

Articolo	Valore di esempio
Nome della funzione per il progetto di funzioni	RulesFunction
Nome dello spazio dei nomi per il progetto di funzioni	Contoso
App per la logica:	LogicApp
Modello flusso di lavoro: - Flusso di lavoro con stato - Flusso di lavoro senza stato	Workflow a stato persistente
Nome flusso di lavoro	MyRulesWorkflow

Selezionare Apri nella finestra corrente.

Al termine di questo passaggio, Visual Studio Code crea l'area di lavoro, che include un progetto di funzioni e un progetto di motore di regole dell'app di logica, ad esempio:

Nodo	Descrizione
*< nome dell'area di lavoro>*	Contiene sia il progetto della funzione che il progetto di flusso di lavoro dell'app logica.
Funzione	Contiene gli artefatti per il progetto della funzione. Ad esempio, il *<file function-name>.cs* è il file di codice in cui è possibile creare il codice.
LogicApp	Contiene gli artefatti per il progetto del motore di regole della Logic App, incluso un flusso di lavoro.

Scrivere il codice del motore delle regole

Nell'area di lavoro espandere il nodo Funzioni, se non è già espanso.

Apri il file <function-name>.cs, che in questo esempio è denominato RulesFunction.cs.

Per impostazione predefinita, questo file contiene codice di esempio con gli elementi di codice seguenti, insieme ai valori di esempio forniti in precedenza, se appropriati:

Nome del namespace
Nome classe
Nome della funzione
Parametri di funzione
Tipo restituito
Tipo complesso

L'esempio seguente mostra il codice di esempio completo per la funzione denominata RulesFunction:

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------

namespace Contoso
{
     using System;
     using System.Collections.Generic;
     using System.Threading.Tasks;
     using Microsoft.Azure.Functions.Extensions.Workflows;
     using Microsoft.Azure.WebJobs;
     using Microsoft.Azure.Workflows.RuleEngine;
     using Microsoft.Azure.Workflows.RuleEngine.Common;
     using Microsoft.Extensions.Logging;
     using System.Xml;
     using System.Text;

     /// <summary>
     /// Represents the RulesFunction flow invoked function.
     /// </summary>
     public class RulesFunction
     {
         private readonly ILogger<RulesFunction> logger;

         private FileStoreRuleExplorer ruleExplorer;

         public RulesFunction(ILoggerFactory loggerFactory)
         {
             logger = loggerFactory.CreateLogger<RulesFunction>();
             this.ruleExplorer = new FileStoreRuleExplorer(loggerFactory); 
         }

         /// <summary>
         /// Executes the logic app workflow.
         /// </summary>
         /// <param name="ruleSetName">The rule set name.</param>
         /// <param name="documentType">document type of input xml.</param>
         /// <param name="inputXml">input xml type fact</param>
         /// <param name="purchaseAmount">purchase amount, value used to create .NET fact </param>
         /// <param name="zipCode">zip code value used to create .NET fact .</param>
         [FunctionName("RulesFunction")]
         public Task<RuleExecutionResult> RunRules(
             [WorkflowActionTrigger] string ruleSetName, 
             string documentType, 
             string inputXml, 
             int purchaseAmount, 
             string zipCode)
         {
         /***** Summary of steps below *****
              * 1. Get the rule set to Execute 
              * 2. Check if the rule set was retrieved successfully
              * 3. create the rule engine object
              * 4. Create TypedXmlDocument facts for all xml document facts
              * 5. Initialize .NET facts
              * 6. Execute rule engine
              * 7. Retrieve relevant updates facts and send them back
         */

             try
             {
                 var ruleSet = this.ruleExplorer.GetRuleSet(ruleSetName);

                 // Check if ruleset exists
                 if(ruleSet == null)
                 {
                     // Log an error in finding the rule set
                     this.logger.LogCritical($"RuleSet instance for '{ruleSetName}' was not found(null)");
                     throw new Exception($"RuleSet instance for '{ruleSetName}' was not found.");
                 }             

                 // Create rule engine instance
                 var ruleEngine = new RuleEngine(ruleSet: ruleSet);

                 // Create a typedXml Fact(s) from input xml(s)
                 XmlDocument doc = new XmlDocument();
                 doc.LoadXml(inputXml);
                 var typedXmlDocument = new TypedXmlDocument(documentType, doc);

                 // Initialize .NET facts
                 var currentPurchase = new ContosoNamespace.ContosoPurchase(purchaseAmount, zipCode);

                 // Provide facts to rule engine and run it
                 ruleEngine.Execute(new object[] { typedXmlDocument, currentPurchase });

                 // Send the relevant results(facts) back
                 var updatedDoc = typedXmlDocument.Document as XmlDocument;
                 var ruleExectionOutput = new RuleExecutionResult()
                 {
                     XmlDoc = updatedDoc.OuterXml,
                     PurchaseAmountPostTax = currentPurchase.PurchaseAmount + currentPurchase.GetSalesTax()
                 };

                 return Task.FromResult(ruleExectionOutput);
             }
             catch(RuleEngineException ruleEngineException)
             {
                 // Log any rule engine exceptions
                 this.logger.LogCritical(ruleEngineException.ToString());
                 throw;
             }
             catch(XmlException xmlException)
             {
                 // Log any xml exceptions
                 this.logger.LogCritical("Encountered exception while handling xml. " + xmlException.ToString());
                 throw;
             }
             catch(Exception ex)
             {
                 // Log any other exceptions
                 this.logger.LogCritical(ex.ToString());
                 throw;
             }
         }

         /// <summary>
         /// Results of the rule execution
         /// </summary>
         public class RuleExecutionResult
         {
             /// <summary>
             /// rules updated xml document
             /// </summary>
             public string XmlDoc { get; set;}

             /// <summary>
             /// Purchase amount post tax
             /// </summary>
             public int PurchaseAmountPostTax { get; set;}
         }
     }
}

La definizione di funzione per RulesFunction include un metodo predefinito RunRules che è possibile usare per iniziare. Questo metodo di esempio RunRules illustra come passare i parametri al motore delle regole delle app logiche di Azure. In questo esempio, il metodo passa il nome del set di regole, il tipo di documento di input, un fatto XML e altri valori per un'ulteriore elaborazione.

Il file <function-name>.cs include anche l'interfaccia ILogger, che fornisce il supporto per la registrazione degli eventi in una risorsa di Application Insights. È possibile inviare informazioni di traccia ad Application Insights e archiviare tali informazioni insieme alle informazioni di traccia dai flussi di lavoro. Il < file function-name>.cs include anche l'oggetto FileStoreRuleExplorer che accede al set di regole. Come si può osservare, il costruttore per l'oggetto FileStoreRuleExplorer usa loggerFactory per inviare informazioni di telemetria anche ad Application Insights:

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

public RulesFunction(ILoggerFactory loggerFactory)
     {
         logger = loggerFactory.CreateLogger<RulesFunction>();
         this.ruleExplorer = new FileStoreRuleExplorer(loggerFactory); 
     }

    <...>

Il motore delle regole di Azure Logic Apps opera come descritto nei seguenti passaggi:

Il motore usa l'oggetto FileStoreRuleExplorer per accedere al set di regole. Il file del set di regole viene archiviato nella directory Rules per l'app di logica Standard.

Per questo esempio, il file del set di regole è denominato SampleRuleSet.xml, che è stato creato usando Microsoft Rules Composer o esportato con Microsoft BizTalk Server.

var ruleSet = this.ruleExplorer.GetRuleSet(ruleSetName);

// Check if ruleset exists
if(ruleSet == null)
{
// Log an error in finding the rule set
  this.logger.LogCritical($"RuleSet instance for '{ruleSetName}' was not found(null)");
  throw new Exception($"RuleSet instance for '{ruleSetName}' was not found.");
}

Importante

I set di regole contengono riferimenti ai relativi fatti. Microsoft Rules Composer cerca gli assembly dei fatti per convalidare l'insieme di regole ai fini della modifica. Per aprire set di regole come SampleRuleSet.xml in Microsoft Rules Composer, è necessario inserirli con gli assembly dei fatti .NET corrispondenti. In caso contrario, viene generata un'eccezione.

Il motore usa l'oggetto ruleSet per creare un'istanza dell'oggetto RuleEngine .
L'oggetto RuleEngine riceve i fatti della regola usando il Execute metodo .

In questo esempio il Execute metodo riceve due fatti: un fatto XML denominato typedXmlDocument e un fatto .NET denominato currentPurchase.

Dopo l'esecuzione del motore, i valori dei fatti vengono sovrascritti con i valori risultanti dall'esecuzione del motore:

// Create rule engine instance
var ruleEngine = new RuleEngine(ruleSet: ruleSet);
// Create a typedXml Fact(s) from input xml(s)
XmlDocument doc = new XmlDocument();
doc.LoadXml(inputXml);
var typedXmlDocument = new TypedXmlDocument(documentType, doc);
// Initialize .NET facts
var currentPurchase = new ContosoNamespace.ContosoPurchase(purchaseAmount, zipCode);
// Provide facts to rule engine and run it
ruleEngine.Execute(new object[] { typedXmlDocument, currentPurchase });
// Send the relevant results(facts) back
   var updatedDoc = typedXmlDocument.Document as XmlDocument;

Il motore usa la RuleExecutionResult classe personalizzata per restituire i valori al RunRules metodo :

var ruleExectionOutput = new RuleExecutionResult()
             {
                 XmlDoc = updatedDoc.OuterXml,
                 PurchaseAmountPostTax = currentPurchase.PurchaseAmount + currentPurchase.GetSalesTax()
             };

             return Task.FromResult(ruleExectionOutput);

Sostituire il codice della funzione di esempio con il proprio e modificare il metodo predefinito RunRules per gli scenari personalizzati.

Questo esempio continua a usare il codice di esempio senza alcuna modifica.

Creare e compilare il codice

Dopo aver completato la scrittura del codice, compilare per assicurarsi che non esistano errori di compilazione. Il progetto di funzione include automaticamente le attività di compilazione, che compilano e quindi aggiungono qualsiasi libreria di codice personalizzata, inclusi gli assembly .NET, alla cartella lib\custom nel progetto dell'app logica dove i workflow cercano funzioni personalizzate da eseguire. Queste attività inseriscono gli assembly nella cartella lib\custom\net472.

In Visual Studio Code, dal menu Terminale, selezionare Nuovo terminale.
Nell'elenco di directory di lavoro visualizzato, selezionare Funzioni come directory di lavoro corrente per il nuovo terminale.

Visual Studio Code apre una finestra del terminale con un prompt dei comandi.
Nella finestra Terminale immettere dotnet restore .\RulesFunction.csproj al prompt dei comandi.
Dopo che il prompt dei comandi viene nuovamente visualizzato, immettere dotnet build .\RulesFunction.csproj.

Se la compilazione ha esito positivo, nella finestra Terminale viene segnalato che la compilazione è riuscita.
Verificare che nel progetto dell'app per la logica siano presenti gli elementi seguenti:
- Nell'area di lavoro, espandi le seguenti cartelle: LogicApp>lib\custom>net472. Verificare che la sottocartella denominata net472 contenga più assembly necessari per eseguire il codice, incluso un file denominato< function-name>.dll.
- Nell'area di lavoro espandere le cartelle seguenti: LogicApp>lib\custom><function-name>. Verificare che la sottocartella denominata <function-name> contenga un file function.json, che include i metadati relativi al codice della funzione scritto. Il progettista di flussi di lavoro usa questo file per determinare gli input e gli output necessari quando si chiama il tuo codice.
L'esempio seguente presenta gli assembly di esempio generati e altri file nel progetto dell'applicazione logica.

Chiamare le regole da un flusso di lavoro

Dopo aver verificato che il codice si compila e che il progetto del motore di regole dell'app logica contenga i file necessari per eseguire il codice, aprire il flusso di lavoro predefinito incluso nel tuo progetto di app logica.

Nell'area di lavoro, in LogicApp, espandere il nodo <workflow-name>, aprire il menu di scelta rapida per workflow.json e selezionare Apri finestra di progettazione.

Nella finestra di progettazione del flusso di lavoro che si apre, il flusso di lavoro predefinito, incluso nel progetto di app per la logica, viene visualizzato con il trigger e le azioni seguenti:
- Trigger di richiesta predefinito denominato Quando viene ricevuta una richiesta HTTP.
- Azione predefinita denominata Chiamare una funzione regole locali in questa app per la logica.
- Azione predefinita Response denominata Response, che viene usata per rispondere al chiamante solo quando si usa il trigger Richiesta.
Selezionare l'azione denominata Chiamare una funzione regole locali in questa app logica.

Il riquadro informazioni dell'azione si apre sul lato destro.
Rivedere e confermare che il valore del Nome della funzione parametro sia impostato sulla funzione delle regole da eseguire. Esaminare o modificare qualsiasi altro valore di parametro usato dalla funzione.

Eseguire il debug del codice e del flusso di lavoro

Ripetere i passaggi seguenti per avviare l'emulatore di archiviazione Azurite tre volte: una volta per ogni servizi di Archiviazione di Azure seguente:
- Servizio Blob di Azure
- Servizio di accodamento di Azure
- Servizio tabelle di Azure
1. Dal menu Visualizza di Visual Studio Code, selezionare Riquadro comandi.
2. Nel prompt visualizzato, trovare e selezionare Azurite: Avvia servizio BLOB.
3. Nell'elenco di directory di lavoro visualizzato, selezionare LogicApp.
4. Ripetere questi passaggi per Azurite: Avvia Servizio di Coda e Azurite: Avvia Servizio Tabelle.
Il processo ha funzionato quando la barra delle applicazioni di Visual Studio Code, nella parte inferiore della schermata, mostra i tre servizi di archiviazione in esecuzione, ad esempio:
Nella barra delle attività di Visual Studio Code, selezionare Avvia ed esegui debug. (Tastiera: CTRL+MAIUSC+D)
Nell'elenco Avvia ed esegui debug, selezionare Collegati all'app per la logica (LogicApp), se non è già selezionata. Quindi selezionare Esegui (freccia verde).

Viene visualizzata la finestra Terminale e viene visualizzato il processo di debug avviato. Viene quindi visualizzata la finestra Console di debug che mostra gli stati di debug. Nella parte inferiore di Visual Studio Code, la barra delle applicazioni diventa arancione, a indicare che il debugger .NET è caricato.
Per impostare eventuali punti di interruzione, nella definizione della funzione (<nome> funzione.cs) o nella definizione del flusso di lavoro (workflow.json), individuare il numero di riga in cui si desidera il punto di interruzione e selezionare la colonna sul lato sinistro, ad esempio:
Per eseguire manualmente il trigger Richiesta nel flusso di lavoro, aprire la pagina Panoramica del flusso di lavoro.
1. Dal progetto dell'app per la logica, aprire il menu di scelta rapida del file di workflow.json e selezionare Panoramica.
  
  Nella pagina Panoramica del flusso di lavoro, il pulsante Esegui trigger è disponibile per quando si vuole avviare manualmente il flusso di lavoro. Nelle Proprietà del flusso di lavoro, il valore dell'URL di callback è l'URL di un endpoint chiamabile creato dal trigger di Richiesta nel tuo flusso di lavoro. È possibile inviare richieste a questo URL per attivare il flusso di lavoro da altre applicazioni, inclusi altri workflow di app logiche.
Nella barra degli strumenti della pagina Panoramica, selezionare Esegui trigger.

Dopo l'avvio dell'esecuzione del flusso di lavoro, il debugger attiva il primo punto di interruzione.
Nel menu Esegui o nella barra degli strumenti del debugger, selezionare un' azione di debug.

Al termine dell'esecuzione del flusso di lavoro, la pagina Panoramica mostra l'esecuzione completata con i relativi dettagli di base.
Per esaminare altre informazioni sull'esecuzione del flusso di lavoro, selezionare l'esecuzione completata. In alternativa, nell'elenco accanto alla colonna Durata, selezionare Mostra esecuzione.
Per distribuire le app logiche con il progetto Motore Regole in Azure Logic Apps, seguire la procedura descritta in Preparare la distribuzione.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-03-11