Dela via

Skapa ett Azure Logic Apps Rules Engine-projekt med Visual Studio Code (förhandsversion)

  • Artikel

Gäller för: Azure Logic Apps (Standard)

Viktigt!

Den här funktionen är i förhandsversion och omfattas av kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.

När du vill integrera affärslogik med dina Standard-arbetsflöden i Azure Logic Apps kan du skapa och skapa ett Azure Logic Apps Rules Engine-projekt med hjälp av Visual Studio Code. Regler styr affärslogik för hur affärsprocesser fungerar.

Den här instruktionsguiden beskriver hur du skapar ett Azure Logic Apps Rules Engine-projekt:

  • Krav och konfiguration för att skapa ditt Azure Logic Apps Rules Engine-projekt, inklusive att skapa affärsregler för ditt projekt med Microsoft Rules Composer.

  • Exportera befintliga regler från Microsoft BizTalk Server om du har några.

  • Skapa ett Standard logic apps-projekt för Azure Logic Apps Rules Engine med hjälp av Visual Studio Code.

Förutsättningar

Innan du skapar projektet

För att säkerställa ett lyckat regelmotorprojekt kan du granska och utföra följande allmänna uppgifter och metodtips:

  1. Fastställ hur affärsregler passar in i dina affärsprocesser.

  2. Planera hur du ska införliva affärsregler i ditt program.

  3. Identifiera den affärslogik som du vill representera med regler i ditt program.

    Termen "affärslogik" kan referera till många saker. Affärslogik kan till exempel vara "Inköpsorder som är större än 500 dollar kräver chefgodkännande".

  4. Identifiera datakällor för dina regelelement. Du kan också definiera vokabulärer, som är domänspecifika nomenklatur som representerar underliggande bindningar.

  5. Definiera de regler som ska användas från ordförrådsdefinitioner eller direkt från databindningar. Från dessa regler skapar du en regeluppsättning som representerar din affärslogik.

Exportera regler från Microsoft BizTalk Server

Om du vill återanvända befintliga regler från Microsoft BizTalk Server kan du exportera dem. Db-fakta stöds dock inte för närvarande. Innan du exporterar dina regler tar du bort eller omstrukturerar dem till andra typer av fakta med hjälp av Microsoft BizTalk Rules Composer.

  1. Starta distributionsguiden för business rules engine från Microsoft BizTalk Server.

  2. På sidan Välkommen till distributionsguiden för regelmotorn väljer du Nästa.

  3. På sidan Distributionsaktivitet väljer du Exportera princip/vokabulär till fil från databasen och väljer Nästa.

  4. På sidan Principarkiv går du till listan SQL Server-namn och väljer din SQL-server. I listan Konfigurationsdatabas på vald server väljer du BizTalkRuleEngineDb och sedan Nästa.

  5. På sidan Exportera princip/vokabulär väljer du den princip som du vill använda i listan Princip . Om du vill hitta och välja definitionsfilen väljer du Bläddra.

  6. När du är klar väljer du Nästa.

  7. Bekräfta informationen om servern, databasen och principen eller vokabulären och välj Nästa.

  8. När importen eller exporten är klar väljer du Nästa.

  9. Granska slutförandestatusen för importen eller exporten och välj Slutför.

Skapa ett Azure Logic Apps Rules Engine-projekt

  1. I Visual Studio Code går du till aktivitetsfältet och väljer Azure-ikonen. (Tangentbord: Skift+Alt+A)

  2. I azure-fönstret som öppnas går du till verktygsfältet Arbetsyta i Azure Logic Apps-menyn och väljer Skapa ny arbetsyta för logikappar.

    Skärmbild som visar Visual Studio Code, Azure-fönstret, verktygsfältet arbetsyteavsnitt och valt alternativ för Skapa ny logikappsarbetsyta.

  3. I rutan Välj mapp bläddrar du till och väljer den lokala mapp som du skapade för projektet.

  4. När promptrutan Skapa ny logikappsarbetsyta visas anger du ett namn på din arbetsyta:

    Skärmbild som visar Visual Studio Code med uppmaningen att ange arbetsytans namn.

    Det här exemplet fortsätter med MyLogicAppRulesWorkspace.

  5. När rutan Välj en projektmall för arbetsyteprompten för logikappen visas väljer du Logikapp med regelmotorprojekt (förhandsversion).

    Skärmbild som visar Visual Studio Code med uppmaningen att välja projektmall för logikappens arbetsyta.

  6. Följ de efterföljande anvisningarna för att ange följande exempelvärden:

    Artikel Exempelvärde
    Funktionsnamn för funktionsprojekt RulesFunction
    Namnområdesnamn för funktionsprojekt Contoso.Enterprise
    Arbetsflödesmall:
    - Tillståndskänsligt arbetsflöde
    - Tillståndslöst arbetsflöde    		 Tillståndskänsligt arbetsflöde
    Arbetsflödesnamn MyRulesWorkflow

  7. Välj Öppna i aktuellt fönster.

    När du har slutfört det här steget skapar Visual Studio Code din arbetsyta, som innehåller ett funktionsprojekt och ett logikappsregelmotorprojekt, som standard, till exempel:

    Skärmbild som visar Visual Studio Code med den skapade arbetsytan.

    Nod beskrivning
    <arbetsytans namn> Innehåller både ditt funktionsprojekt och logikappens arbetsflödesprojekt.
    Funktion Innehåller artefakterna för funktionsprojektet. Till exempel är funktionsnamnet><.cs filen den kodfil där du kan skapa din kod.
    LogicApp Innehåller artefakterna för logikappens regelmotorprojekt, inklusive ett arbetsflöde.

Skriva kod för regelmotorn

  1. På arbetsytan expanderar du noden Functions, om den inte redan har expanderats.

  2. <Öppna filen function-name>.cs som heter RulesFunction.cs i det här exemplet.

    Som standard innehåller den här filen exempelkod som har följande kodelement tillsammans med tidigare angivna exempelvärden där det är lämpligt:

    • Namn på namnområde
    • Klassnamn
    • Funktionsnamn
    • Funktionsparametrar
    • Returtyp
    • Komplex typ

    I följande exempel visas den fullständiga exempelkoden för funktionen med namnet 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;}
        }
    }
}

    Funktionsdefinitionen för RulesFunction innehåller en standardmetod RunRules som du kan använda för att komma igång. Den här exempelmetoden RunRules visar hur du skickar parametrar till Azure Logic Apps-regelmotorn. I det här exemplet skickar metoden regeluppsättningens namn, indatadokumenttypen, ett XML-faktum och andra värden för vidare bearbetning.

    Funktionsnamnet><.cs filen innehåller ILogger även gränssnittet, som ger stöd för loggningshändelser till en Application Insights-resurs. Du kan skicka spårningsinformation till Application Insights och lagra den informationen tillsammans med spårningsinformationen från dina arbetsflöden, till exempel:

    private readonly ILogger<RulesFunction> logger;

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

    Regelmotorn för Azure Logic Apps fungerar enligt beskrivningen i följande steg:

    1. Motorn använder objektet FileStoreRuleExplorer för att komma åt regeluppsättningen. Regeluppsättningsfilen lagras i katalogen Regler för standardlogikappen.

      I det här exemplet kallas SampleRuleSet.xmlregeluppsättningsfilen , som skapades med antingen Microsoft Rules Composer eller exporterades med Hjälp av 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.");
}

      Viktigt!

      Regeluppsättningar innehåller referenser till deras fakta. Microsoft Rules Composer söker efter faktasammansättningar för att verifiera regeluppsättningen för redigering. Om du vill öppna regeluppsättningar som SampleRuleSet.xml i Microsoft Rules Composer måste du placera dem med motsvarande .NET-faktasammansättningar. Annars får du ett undantag.

    2. Motorn använder objektet ruleSet för att skapa en instans av RuleEngine objektet.

    3. Objektet RuleEngine tar emot regelns fakta med hjälp av Execute metoden .

      I det här exemplet Execute tar metoden emot två fakta: ett XML-faktum med namnet typedXmlDocument och ett .NET-fakta med namnet currentPurchase.

      När motorn har körts skrivs faktavärdena över med de värden som är resultatet av motorkörningen:

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

    4. Motorn använder den RuleExecutionResult anpassade klassen för att returnera värdena till RunRules metoden:

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

return Task.FromResult(ruleExecutionOutput);

    5. Ersätt exempelfunktionskoden med din egen och redigera standardmetoden RunRules för dina egna scenarier.

      Det här exemplet fortsätter att använda exempelkoden utan ändringar.

Kompilera och skapa din kod

När du har skrivit koden kompilerar du för att se till att det inte finns några byggfel. Funktionsprojektet innehåller automatiskt bygguppgifter, som kompilerar och sedan lägger till något av dina anpassade kodbibliotek, inklusive dina .NET-faktasammansättningar, i mappen lib\custom i logikappsprojektet där arbetsflöden letar efter anpassade funktioner som ska köras. De här uppgifterna placerar sammansättningarna i mappen lib\custom\net472 .

  1. I Visual Studio Code går du till terminalmenyn och väljer Ny terminal.

  2. I arbetskataloglistan som visas väljer du Functions som din aktuella arbetskatalog för den nya terminalen.

    Skärmbild som visar Visual Studio Code, fråga efter aktuell arbetskatalog och vald Functions-katalog.

    Visual Studio Code öppnar ett terminalfönster med en kommandotolk.

  3. I terminalfönstret i kommandotolken anger du dotnet restore .\RulesFunction.csproj.

    Skärmbild som visar kommandot Visual Studio Code, Terminal window och completed dotnet restore.

  4. När kommandotolken visas igen anger du dotnet build .\RulesFunction.csproj.

    Om bygget lyckas rapporterar terminalfönstret att bygget lyckades.

  5. Bekräfta att följande objekt finns i logikappprojektet:

    • På din arbetsyta expanderar du följande mappar: LogicApp>lib\custom>net472. Bekräfta att undermappen med namnet net472 innehåller de flera sammansättningar som krävs för att köra koden, inklusive en fil med namnet< function-name>.dll.

    • På arbetsytan expanderar du följande mappar: LogicApp>lib\custom<>function-name.> Bekräfta att undermappen med namnet <function-name> innehåller en function.json fil, som innehåller metadata om funktionskoden som du skrev. Arbetsflödesdesignern använder den här filen för att fastställa nödvändiga indata och utdata när du anropar koden.

    I följande exempel visas exempelgenererade sammansättningar och andra filer i logikappprojektet:

    Skärmbild som visar logikappens arbetsyta med funktionsprojekt och logikappsprojekt, nu med de genererade sammansättningarna och andra nödvändiga filer.

Anropa dina regler från ett arbetsflöde

När du har bekräftat att koden kompileras och att logikappens regelmotorprojekt har de filer som krävs för att koden ska köras öppnar du standardarbetsflödet som ingår i logikappsprojektet.

  1. Under LogicApp på arbetsytan expanderar <du noden arbetsflödesnamn>, öppnar snabbmenyn för workflow.json och väljer Öppna designer.

    I arbetsflödesdesignern som öppnas visas standardarbetsflödet, som ingår i ditt logikappsprojekt, med följande utlösare och åtgärder:

  2. Välj åtgärden Anropa en lokal regelfunktion i den här logikappen.

    Åtgärdens informationsfönster öppnas till höger.

    Skärmbild som visar Visual Studio Code, arbetsflödesdesigner och standardarbetsflöde med utlösare och åtgärder.

  3. Granska och bekräfta att parametervärdet funktionsnamn är inställt på den regelfunktion som du vill köra. Granska eller ändra andra parametervärden som din funktion använder.

Felsöka din kod och ditt arbetsflöde

  1. Upprepa följande steg för att starta Azurite Storage-emulatorn tre gånger: en gång var för följande Azure Storage-tjänster:

    • Azure Blob Service
    • Azure Kötjänst
    • Azure Table Service

    1. Välj Kommandopalett på menyn i Visual Studio Code-vyn.

    2. I kommandotolken som visas letar du upp och väljer Azurite: Starta Blob Service.

    3. I arbetskataloglistan som visas väljer du LogicApp.

    4. Upprepa de här stegen för Azurite: Start Queue Service och Azurite: Start Table Service.

    Du lyckas när Aktivitetsfältet i Visual Studio Code längst ned på skärmen visar de tre lagringstjänster som körs, till exempel:

    Skärmbild som visar Aktivitetsfältet i Visual Studio Code med Azure Blob Service, Azure Queue Service och Azure Table Service som körs.

  2. I aktivitetsfältet i Visual Studio Code väljer du Kör och Felsöka. (Tangentbord: Ctrl+Skift+D)

    Skärmbild som visar Aktivitetsfältet i Visual Studio Code med Kör och Felsök valt.

  3. I listan Kör och felsök väljer du Anslut till logikappen (LogicApp), om den inte redan är markerad, och väljer sedan Spela upp (grön pil).

    Skärmbild som visar listan Kör och felsöka med Bifoga till logikapp vald och knappen Spela upp markerad.

    Terminalfönstret öppnas och visar den startade felsökningsprocessen. Fönstret Felsökningskonsol visas sedan och visar felsökningsstatusen. Längst ned i Visual Studio Code blir aktivitetsfältet orange, vilket anger att .NET-felsökningsprogrammet läses in.

  4. I listan Kör och felsök väljer du Anslut till .NET Functions (Functions) och sedan Spela upp (grön pil).

    Skärmbild som visar listan Kör och felsöka med Anslut till NET Functions valt och knappen Spela upp har valts.

  5. Om du vill ange brytpunkter i funktionsdefinitionen (<funktionsnamn>.cs) eller arbetsflödesdefinitionen (workflow.json) letar du reda på radnumret där du vill ha brytpunkten och väljer kolumnen till vänster, till exempel:

    Skärmbild som visar Visual Studio Code och den öppna funktionskodfilen med en brytpunkt inställd för en rad i kod.

  6. Om du vill köra utlösaren Begäran manuellt i arbetsflödet öppnar du arbetsflödets översiktssida.

    1. Öppna workflow.json-filens snabbmeny i logikappsprojektet och välj Översikt.

      På arbetsflödets översiktssida är knappen Kör utlösare tillgänglig för när du vill starta arbetsflödet manuellt. Under Egenskaper för arbetsflöde är värdet för återanrops-URL:en URL:en för en anropsbar slutpunkt som skapas av utlösaren Förfrågning i arbetsflödet. Du kan skicka begäranden till den här URL:en för att utlösa arbetsflödet från andra appar, inklusive andra arbetsflöden för logikappar.

      Skärmbild som visar Visual Studio Code och arbetsflödets översiktssida öppnad.

  7. I verktygsfältet Översikt väljer du Kör utlösare.

    När arbetsflödet har börjat köras aktiverar felsökningsprogrammet din första brytpunkt.

  8. I verktygsfältet Kör eller felsökaren väljer du en felsökningsåtgärd.

    När arbetsflödeskörningen har slutförts visar sidan Översikt den färdiga körningen och grundläggande information om den körningen.

  9. Om du vill granska mer information om arbetsflödeskörningen väljer du den färdiga körningen. I listan bredvid kolumnen Varaktighet väljer du Visa körning.

    Skärmbild som visar Visual Studio Code och slutförd arbetsflödeskörning.

Relaterat innehåll