Een Azure Logic Apps Rules Engine-project maken met Visual Studio Code (preview)

Artikel
01/27/2025

Van toepassing op: Azure Logic Apps (Standard)

Belangrijk

Deze mogelijkheid is in preview en is onderworpen aan de aanvullende gebruiksvoorwaarden voor Microsoft Azure Previews.

Wanneer u bedrijfslogica wilt integreren met uw Standaardwerkstromen in Azure Logic Apps, kunt u een Azure Logic Apps Rules Engine-project maken en bouwen met behulp van Visual Studio Code. Regels bepalen de bedrijfslogica voor de werking van bedrijfsprocessen.

In deze handleiding wordt beschreven hoe u een Azure Logic Apps Rules Engine-project maakt:

Vereisten en installatie voor het maken van uw Azure Logic Apps Rules Engine-project, inclusief het maken van de bedrijfsregels voor uw project met de Microsoft Rules Composer.
Exporteer bestaande regels van Microsoft BizTalk Server, indien aanwezig.
Maak een Standaard logic apps-project voor de Azure Logic Apps-regelengine met behulp van Visual Studio Code.

Vereisten

Download en installeer de Microsoft Rules Composer, waarmee u regelsets, bedrijfsregels en woordenlijsten maakt.

Raadpleeg de volgende documentatie voor het bouwen van het bedrijf voor uw regelengineproject:
- Regels maken met Microsoft Rules Composer
- Integratie van beslissingsbeheer en bedrijfslogica met behulp van de Regelengine van Azure Logic Apps
Voor deze release ondersteunt alleen Visual Studio Code de ontwikkelervaring voor een Azure Logic Apps Rules Engine-project. Zie Een standaardwerkstroom voor logische apps maken in Azure Logic Apps met één tenant met behulp van Visual Studio Code om te voldoen aan de vereisten voor het gebruik van Visual Studio Code.
De Azure Logic Apps-regelengine maakt gebruik van de functiefunctie voor aangepaste code in Visual Studio Code. Zie .NET Framework-code maken en uitvoeren vanuit Standard-werkstromen in Azure Logic Apps om te voldoen aan de vereisten voor het gebruik van deze mogelijkheid.

Voordat u uw project maakt

Bekijk en voer de volgende algemene taken en best practices uit om ervoor te zorgen dat het project voor een regelengine succesvol is:

Bepaal hoe bedrijfsregels in uw bedrijfsprocessen passen.
Plan hoe u bedrijfsregels in uw toepassing kunt opnemen.
Identificeer de bedrijfslogica die u wilt weergeven met regels in uw toepassing.

De term 'bedrijfslogica' kan verwijzen naar veel dingen. Bedrijfslogica kan bijvoorbeeld 'Inkooporders groter dan 500 dollar vereisen goedkeuring van de manager'.
Identificeer gegevensbronnen voor uw regelelementen. U kunt desgewenst woordenlijsten definiëren. Dit zijn domeinspecifieke nomenclatuur die onderliggende bindingen vertegenwoordigt.
Definieer de regels die moeten worden gebruikt vanuit woordenlijstdefinities of rechtstreeks vanuit gegevensbindingen. Maak op basis van deze regels een regelset die uw bedrijfslogica vertegenwoordigt.

Regels exporteren van Microsoft BizTalk Server

Als u bestaande regels van Microsoft BizTalk Server opnieuw wilt gebruiken, kunt u deze exporteren. DB-feiten worden momenteel echter niet ondersteund. Voordat u uw regels exporteert, moet u deze verwijderen of herstructureren in andere soorten feiten met behulp van de Microsoft BizTalk Rules Composer.

Start vanuit Microsoft BizTalk Server de wizard Implementatie van de business rules engine.
Selecteer Volgende op de pagina Welkom bij de wizard Implementatie van regelengine.
Op de pagina Implementatietaak selecteert u Beleid/woordenlijst exporteren naar bestand in de database en selecteert u Volgende.
Selecteer uw SQL-server in de lijst SQL Server-naam op de pagina Beleidsarchief. Selecteer BizTalkRuleEngineDb in de configuratiedatabase op de geselecteerde serverlijst en selecteer vervolgens Volgende.
Selecteer op de pagina Beleid/Woordenlijst exporteren het gewenste beleid in de lijst Beleid . Als u het definitiebestand wilt zoeken en kiezen, selecteert u Bladeren.
Wanneer u klaar bent, selecteert u Volgende.
Bevestig de server-, database- en beleids- of vocabulaire informatie en selecteer Volgende.
Nadat het importeren of exporteren is voltooid, selecteert u Volgende.
Controleer de voltooiingsstatus voor het importeren of exporteren en selecteer Voltooien.

Een Azure Logic Apps Rules Engine-project maken

Selecteer in Visual Studio Code op de activiteitenbalk het Azure-pictogram . (Toetsenbord: Shift+Alt+A)
Selecteer in het Azure-venster dat wordt geopend, op de werkbalk werkruimte, in het menu Van Azure Logic Apps de optie Nieuwe werkruimte voor logische apps maken.
Blader in het vak Map selecteren naar en selecteer de lokale map die u voor uw project hebt gemaakt.
Wanneer het promptvak Nieuwe logische app-werkruimte maken wordt weergegeven, geeft u een naam op voor uw werkruimte:

Dit voorbeeld gaat verder met MyLogicAppRulesWorkspace.
Wanneer het promptvak Voor de prompt voor de logische app-werkruimte selecteren wordt weergegeven, selecteert u Logische app met het regelengineproject (preview).

Volg de volgende aanwijzingen om de volgende voorbeeldwaarden op te geven:

Artikel	Voorbeeldwaarde
Functienaam voor functions-project	RulesFunction
Naamruimtenaam voor functions-project	Contoso.Enterprise
Werkstroomsjabloon: - Stateful werkstroom - Staatloze werkstroom	Stateful werkstroom
Werkstroomnaam	MyRulesWorkflow

Selecteer Openen in het huidige venster.

Nadat u deze stap hebt voltooid, maakt Visual Studio Code uw werkruimte, waaronder een functions-project en een engineproject voor logische apps, standaard:

Knooppunt	Beschrijving
*<werkruimtenaam>*	Bevat zowel uw functieproject als het werkstroomproject van de logische app.
Functie	Bevat de artefacten voor uw functieproject. Het bestand met de *<functienaam>.cs* is bijvoorbeeld het codebestand waarin u uw code kunt ontwerpen.
LogicApp	Bevat de artefacten voor het engineproject voor logische apps, inclusief een werkstroom.

Code voor de regelengine schrijven

Vouw in uw werkruimte het Functions-knooppunt uit als dit nog niet is uitgevouwen.

Open het <functienaam>.cs bestand, dat in dit voorbeeld RulesFunction.cs heet.

Dit bestand bevat standaard voorbeeldcode met de volgende code-elementen, samen met de eerder opgegeven voorbeeldwaarden, indien van toepassing:

Naam van naamruimte
Klassenaam
Functienaam
Functieparameters
Retourtype
Complex type

In het volgende voorbeeld ziet u de volledige voorbeeldcode voor de functie met de naam 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;}
        }
    }
}

De functiedefinitie voor RulesFunction bevat een standaardmethode RunRules die u kunt gebruiken om aan de slag te gaan. Deze voorbeeldmethode RunRules laat zien hoe u parameters doorgeeft aan de Regelengine van Azure Logic Apps. In dit voorbeeld geeft de methode de naam van de regelset, het invoerdocumenttype, een XML-feit en andere waarden door voor verdere verwerking.

De <functienaam>.cs bevat ook de ILogger interface, die ondersteuning biedt voor het vastleggen van gebeurtenissen in een Application Insights-resource. U kunt traceringsgegevens verzenden naar Application Insights en deze informatie opslaan naast de traceringsgegevens uit uw werkstromen, bijvoorbeeld:

private readonly ILogger<RulesFunction> logger;

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

De Regelengine van Azure Logic Apps werkt zoals beschreven in de volgende stappen:

De engine gebruikt het FileStoreRuleExplorer object voor toegang tot de regelset. Het regelsetbestand wordt opgeslagen in de map Regels voor uw standaard logische app.

In dit voorbeeld wordt het regelsetbestand aangeroepen SampleRuleSet.xml, dat is gemaakt met behulp van De Microsoft Rules Composer of geëxporteerd met Behulp van 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.");
}
```
Belangrijk

Regelsets bevatten verwijzingen naar hun feiten. De Microsoft Rules Composer zoekt naar de assembly's van de feiten om de regelset te valideren voor bewerking. Als u regelsets wilt openen, zoals SampleRuleSet.xml in Microsoft Rules Composer, moet u ze plaatsen met de bijbehorende assembly's met .NET-feiten. Anders krijgt u een uitzondering.
De engine gebruikt het ruleSet object om een exemplaar van het RuleEngine object te maken.

Het RuleEngine object ontvangt de feiten van de regel met behulp van de Execute methode.

In dit voorbeeld ontvangt de Execute methode twee feiten: een XML-feit met de naam typedXmlDocument en een .NET-feit met de naam currentPurchase.

Nadat de engine wordt uitgevoerd, worden de waarden van de feiten overschreven met de waarden die het resultaat zijn van de uitvoering van de engine:

// 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;

De engine gebruikt de RuleExecutionResult aangepaste klasse om de waarden te retourneren aan de RunRules methode:

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

return Task.FromResult(ruleExecutionOutput);

Vervang de voorbeeldfunctiecode door uw eigen code en bewerk de standaardmethode RunRules voor uw eigen scenario's.

In dit voorbeeld wordt de voorbeeldcode zonder wijzigingen gebruikt.

Uw code compileren en bouwen

Nadat u klaar bent met het schrijven van uw code, compileert u om ervoor te zorgen dat er geen buildfouten bestaan. Uw functieproject bevat automatisch buildtaken, die uw aangepaste codebibliotheken compileren en vervolgens toevoegen, inclusief uw .NET-feitenassembly's, aan de lib\custom-map in uw logische app-project, waar werkstromen zoeken naar aangepaste functies die moeten worden uitgevoerd. Met deze taken worden de assembly's in de map lib\custom\net472 geplaatst.

Selecteer in Visual Studio Code in het menu Terminal de optie Nieuwe terminal.
Selecteer Functies in de lijst met werkmapen die wordt weergegeven als uw huidige werkmap voor de nieuwe terminal.

Visual Studio Code opent een terminalvenster met een opdrachtprompt.
Voer in het terminalvenster bij de opdrachtprompt dotnet restore .\RulesFunction.csproj in.
Nadat de opdrachtprompt opnieuw wordt weergegeven, voert u dotnet-build .\RulesFunction.csproj in.

Als uw build slaagt, rapporteert het Terminal-venster dat de build is geslaagd.
Controleer of de volgende items aanwezig zijn in uw logische app-project:
- Vouw in uw werkruimte de volgende mappen uit: LogicApp>lib\custom>net472. Controleer of de submap met de naam net472 de meerdere assembly's bevat die nodig zijn om uw code uit te voeren, inclusief een bestand met de naam< functienaam>.dll.
- Vouw in uw werkruimte de volgende mappen uit: LogicApp>lib\custom<>function-name.> Controleer of de submap met de naam <functienaam> een function.json-bestand bevat, inclusief de metagegevens over de functiecode die u hebt geschreven. De werkstroomontwerper gebruikt dit bestand om de benodigde invoer en uitvoer te bepalen bij het aanroepen van uw code.
In het volgende voorbeeld ziet u voorbeeld van gegenereerde assembly's en andere bestanden in het project van de logische app:

Uw regels aanroepen vanuit een werkstroom

Nadat u hebt bevestigd dat uw code wordt gecompileerd en dat uw engineproject voor logische apps de benodigde bestanden heeft om uw code uit te voeren, opent u de standaardwerkstroom die is opgenomen in uw logische app-project.

Vouw in uw werkruimte onder LogicApp het< werkstroomnaamknooppunt> uit, open het snelmenu voor workflow.json en selecteer Open Designer.

In de werkstroomontwerper die wordt geopend, wordt de standaardwerkstroom, die deel uitmaakt van uw logische app-project, weergegeven met de volgende trigger en acties:
- De ingebouwde aanvraagtrigger met de naam Wanneer een HTTP-aanvraag wordt ontvangen.
- De ingebouwde actie met de naam Een lokale regelfunctie aanroepen in deze logische app.
- De ingebouwde antwoordactie met de naam Antwoord, die u gebruikt om de beller alleen te beantwoorden wanneer u de aanvraagtrigger gebruikt.
Selecteer de actie met de naam Een lokale regelfunctie aanroepen in deze logische app.

Het informatievenster van de actie wordt aan de rechterkant geopend.
Controleer en controleer of de parameterwaarde Functienaam is ingesteld op de regelfunctie die u wilt uitvoeren. Controleer of wijzig andere parameterwaarden die door uw functie worden gebruikt.

Fouten opsporen in uw code en werkstroom

Herhaal de volgende stappen om de Azurite-opslagemulator drie keer te starten: één keer voor de volgende Azure Storage-services:
- Azure Blob Service
- Azure-wachtrijservice
- Azure Table Service
1. Selecteer opdrachtpalet in het menu Weergave van Visual Studio Code.
2. Zoek en selecteer Azurite bij de prompt die wordt weergegeven: Blob-service starten.
3. Selecteer LogicApp in de lijst met werkmap die wordt weergegeven.
4. Herhaal deze stappen voor Azurite: Start Queue Service en Azurite: Start Table Service.
U bent succesvol wanneer op de taakbalk van Visual Studio Code onder aan het scherm de drie opslagservices worden weergegeven die worden uitgevoerd, bijvoorbeeld:
Selecteer Uitvoeren en fouten opsporen op de activiteitenbalk van Visual Studio Code. (Toetsenbord: Ctrl+Shift+D)
Selecteer In de lijst Uitvoeren en fouten opsporen de optie Koppelen aan logische app (LogicApp) als deze nog niet is geselecteerd en selecteer vervolgens Afspelen (groene pijl).

Het terminalvenster wordt geopend en toont het gestarte foutopsporingsproces. Het venster Foutopsporingsconsole wordt vervolgens weergegeven en toont de foutopsporingsstatussen. Onder aan Visual Studio Code wordt de taakbalk oranje, waarmee wordt aangegeven dat het foutopsporingsprogramma van .NET is geladen.
Selecteer In de lijst Uitvoeren en fouten opsporen de optie Koppelen aan .NET-functies (functies) en selecteer vervolgens Afspelen (groene pijl).
Als u onderbrekingspunten wilt instellen, zoekt u in de functiedefinitie (<functienaam>.cs) of werkstroomdefinitie (workflow.json) het regelnummer op de gewenste positie en selecteert u de kolom aan de linkerkant, bijvoorbeeld:
Als u de aanvraagtrigger handmatig wilt uitvoeren in uw werkstroom, opent u de overzichtspagina van de werkstroom.
1. Open vanuit uw logische app-project het snelmenu van het workflow.json-bestand en selecteer Overzicht.
  
  Op de overzichtspagina van de werkstroom is de knop Trigger uitvoeren beschikbaar voor wanneer u de werkstroom handmatig wilt starten. Onder Werkstroomeigenschappen is de waarde van de callback-URL de URL voor een aanroepbaar eindpunt dat wordt gemaakt door de aanvraagtrigger in uw werkstroom. U kunt aanvragen verzenden naar deze URL om uw werkstroom te activeren vanuit andere apps, inclusief andere werkstromen voor logische apps.
Selecteer Op de werkbalk Overzichtspagina de optie Trigger Uitvoeren.

Nadat uw werkstroom is gestart, activeert het foutopsporingsprogramma uw eerste onderbrekingspunt.
Selecteer een foutopsporingsactie in het menu Uitvoeren of foutopsporingsprogramma.

Nadat de uitvoering van de werkstroom is voltooid, ziet u op de pagina Overzicht de voltooide uitvoering en de basisinformatie over die uitvoering.
Als u meer informatie over de uitvoering van de werkstroom wilt bekijken, selecteert u de voltooide uitvoering. U kunt ook de optie Uitvoeren weergeven selecteren in de lijst naast de kolom Duur.