Creare un progetto motore regole di App per la logica di Azure usando Visual Studio Code (anteprima)

Articolo
12/04/2024

Si applica: App per la logica di Azure (Standard)

Importante

Questa funzionalità è in anteprima ed è soggetta alle Condizioni supplementari per l'utilizzo per le anteprime di Microsoft Azure.

Quando si vuole integrare la logica di business con i flussi di lavoro Standard in App per la logica di Azure, è possibile creare e compilare un progetto motore regole App per la logica di Azure usando Visual Studio Code. Le regole regolano la logica di business per il funzionamento dei processi aziendali.

Questa guida pratica descrive come creare un progetto motore regole di App per la logica di Azure:

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

Prerequisiti

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

Per compilare l'azienda per il progetto del motore regole, vedere la documentazione seguente:
- Creare regole con Microsoft Rules Composer
- Gestione delle decisioni e integrazione della logica di business tramite il motore regole di App per la logica di Azure
Per questa versione, solo Visual Studio Code supporta l'esperienza di sviluppo per un progetto motore regole di App per la logica di Azure. 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 regole di App per la logica di Azure usa la funzionalità della 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 garantire un progetto di motore regole riuscito, esaminare ed eseguire le attività e le procedure consigliate generali seguenti:

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 origini 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 fatti 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 avviare la Distribuzione guidata motore regole di business.
Nella pagina Distribuzione guidata motore regole selezionare Avanti.
Nella pagina Attività di distribuzione selezionare Esporta criteri/vocabolario nel file dal database e selezionare Avanti.
Nell'elenco Nome SQL Server della pagina Archivio criteri selezionare 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 regole di App per la logica di Azure

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 per l'app per la logica, selezionare App per la logica con progetto motore regole (anteprima).

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.Enterprise
Modello flusso di lavoro: - Flusso di lavoro con stato - Flusso di lavoro senza stato	Flusso di lavoro con stato
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 motore regole dell'app per la logica, ad esempio:

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

Scrivere il codice del motore regole

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

Aprire il <file function-name>.cs denominato RulesFunction.cs in questo esempio.

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 spazio dei nomi
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.Enterprise
{
    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.Extensions.Logging;
    using System.Xml;

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

        public RulesFunction(ILoggerFactory loggerFactory)
        {
            logger = loggerFactory.CreateLogger<RulesFunction>();
        }

        /// <summary>
        /// Execute the logic app workflow.
        /// </summary>
        /// <param name="ruleSetName">The ruleset name.</param>
        /// <param name="documentType">The document type for the input XML.</param>
        /// <param name="inputXml">The input XML type fact.</param>
        /// <param name="purchaseAmount">The purchase amount value used to create a .NET fact.</param>
        /// <param name="zipCode">The zip code value used to create a .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 ruleset to execute.
            * 2. Check if the ruleset was successfully retrieved.
            * 3. Create the rules engine object.
            * 4. Create TypedXmlDocument facts for all XML document facts.
            * 5. Initialize .NET facts.
            * 6. Execute rules engine.
            * 7. Retrieve relevant updates facts and send them back.
            */

            try
            {
                // Get the ruleset based on the ruleset name.
                 var ruleExplorer = new FileStoreRuleExplorer();
                 var ruleSet = ruleExplorer.GetRuleSet(ruleSetName);

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

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

                // Create one or more typedXmlDocument facts from one or more input XML documents.
                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 and run the rules engine.
                ruleEngine.Execute(new object[] { typedXmlDocument, currentPurchase });

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

                return Task.FromResult(ruleExecutionOutput);
            }
            catch(RuleEngineException ruleEngineException)
            {
                // Log any rules engine exceptions.
                this.logger.LogCritical(ruleEngineException.ToString());
                throw;
            }
        }

        /// <summary>
        /// Results from rules execution
        /// </summary>
        public class RuleExecutionResult
        {
            /// <summary>
            /// Rules updated XML document
            /// </summary>
            public string XmlDoc { get; set;}

            /// <summary>
            /// Purchase amount after 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 regole di App per la logica 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 tracciamento ad Application Insights e archiviare tali informazioni insieme a quelle dei flussi di lavoro, ad esempio:

private readonly ILogger<RulesFunction> logger;

    public RulesFunction(ILoggerFactory loggerFactory)
    {
        logger = loggerFactory.CreateLogger<RulesFunction>();
    }
    <...>

Il motore regole App per la logica di Azure funziona come descritto nei passaggi seguenti:

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 per la 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 ruleExplorer = new FileStoreRuleExplorer();
var ruleSet = ruleExplorer.GetRuleSet(ruleSetName);

// Check if the ruleset exists.
if(ruleSet == null)
{
    // Log an error if the ruleset isn't found.
    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 il set di regole per la 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 rules engine instance.
var ruleEngine = new RuleEngine(ruleSet: ruleSet);

// Create one or more typedXml facts from one or more input XML documents.
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 and run the rules engine.
ruleEngine.Execute(new object[] { typedXmlDocument, currentPurchase });

// Send back the relevant results (facts).
var updatedDoc = typedXmlDocument.Document as XmlDocument;

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

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

return Task.FromResult(ruleExecutionOutput);

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 dei fatti .NET, alla cartella lib\custom nel progetto dell'app per la logica in cui i flussi di lavoro 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 espandere le cartelle seguenti: 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. La finestra di progettazione del flusso di lavoro usa questo file per determinare gli input e gli output necessari quando si chiama il codice.
L'esempio seguente mostra gli assembly di esempio generati e altri file nel progetto dell'app per la logica:

Chiamare le regole da un flusso di lavoro

Dopo aver verificato che il codice viene compilato e che il progetto del motore regole dell'app per la logica contenga i file necessari per l'esecuzione del codice, aprire il flusso di lavoro predefinito incluso nel progetto dell'app per la 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 per la logica.

Il riquadro informazioni dell'azione si apre sul lato destro.
Verificare e verificare che il valore del parametro Nome funzione sia impostato sulla funzione rules 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 accodamento 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 Collega all'app per la logica (LogicApp), se non è già selezionata, e quindi selezionare Riproduci (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.
Nell'elenco Esegui e debug selezionare Connetti a funzioni .NET (Funzioni) e quindi selezionare Riproduci (freccia verde).
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. In Proprietà flusso di lavoro il valore dell'URL di callback è l'URL di un endpoint chiamabile creato dal trigger Richiesta nel flusso di lavoro. È possibile inviare richieste a questo URL per attivare il flusso di lavoro da altre app, inclusi altri flussi di lavoro dell'app per la logica.
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 e i dettagli di base sull'esecuzione.
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.