Vytvoření projektu stroje pravidel Azure Logic Apps pomocí editoru Visual Studio Code (Preview)

Článek
06/13/2024

Platí pro: Azure Logic Apps (Standard)

Důležité

Tato funkce je ve verzi Preview a podléhá dodatečným podmínkám použití pro microsoft Azure Preview.

Pokud chcete integrovat obchodní logiku s vašimi standardními pracovními postupy v Azure Logic Apps, můžete vytvořit a sestavit projekt Stroje pravidel Azure Logic Apps pomocí editoru Visual Studio Code. Pravidla řídí obchodní logiku pro fungování obchodních procesů.

Tento průvodce postupy popisuje, jak vytvořit projekt Azure Logic Apps Rules Engine:

Předpoklady a nastavení pro vytvoření projektu azure Logic Apps Rules Engine, včetně vytvoření obchodních pravidel pro váš projekt pomocí nástroje Microsoft Rules Composer.
Pokud nějaké máte, exportujte existující pravidla z Microsoft BizTalk Serveru.
Vytvořte projekt standardních aplikací logiky pro stroj pravidel Azure Logic Apps pomocí editoru Visual Studio Code.

Požadavky

Stáhněte a nainstalujte nástroj Microsoft Rules Composer, který používáte k vytváření sad pravidel, obchodních pravidel a slovníků.

Pokud chcete vytvořit firmu pro projekt stroje pravidel, projděte si následující dokumentaci:
- Vytváření pravidel pomocí nástroje Microsoft Rules Composer
- Správa rozhodnutí a integrace obchodní logiky pomocí stroje pravidel Azure Logic Apps
V této verzi podporuje vývojové prostředí pro projekt Azure Logic Apps Rules Engine pouze Visual Studio Code. Pokud chcete splnit požadavky pro použití editoru Visual Studio Code, přečtěte si téma Vytvoření pracovního postupu standardní aplikace logiky v Azure Logic Apps s jedním tenantem pomocí editoru Visual Studio Code.
Modul pravidel Azure Logic Apps používá funkci vlastního kódu v editoru Visual Studio Code. Pokud chcete splnit požadavky na použití této funkce, přečtěte si téma Vytvoření a spuštění kódu rozhraní .NET Framework z pracovních postupů Standard v Azure Logic Apps.

Před vytvořením projektu

Pokud chcete zajistit úspěšný projekt modulu pravidel, projděte si a proveďte následující obecné úlohy a osvědčené postupy:

Určete, jak obchodní pravidla odpovídají obchodním procesům.
Naplánujte, jak do aplikace začlenit obchodní pravidla.
Identifikujte obchodní logiku, kterou chcete reprezentovat pomocí pravidel ve vaší aplikaci.

Pojem "obchodní logika" může odkazovat na mnoho věcí. Obchodní logika může být například "Nákupní objednávky větší než 500 dolarů vyžaduje schválení manažera".
Identifikujte zdroje dat pro prvky pravidla. Volitelně můžete definovat slovníky, což jsou terminologie specifická pro doménu, která představuje podkladové vazby.
Definujte pravidla, která se mají použít z definic slovníku nebo přímo z datových vazeb. Z těchto pravidel vytvořte sadu pravidel, která představuje vaši obchodní logiku.

Export pravidel z Microsoft BizTalk Serveru

Pokud chcete znovu použít existující pravidla ze serveru Microsoft BizTalk Server, můžete je exportovat. Fakta databáze se ale v současné době nepodporují. Před exportem pravidel je odeberte nebo refaktorujte do jiných typů faktů pomocí nástroje Microsoft BizTalk Rules Composer.

Na serveru Microsoft BizTalk spusťte Průvodce nasazením stroje obchodních pravidel.
Na stránce Průvodce nasazením stroje pravidel vyberte Další.
Na stránce Úloha nasazení vyberte Exportovat zásady nebo slovník do souboru z databáze a pak vyberte Další.
Na stránce Úložiště zásad v seznamu názvů SQL Serveru vyberte váš SQL server. V seznamu konfigurační databáze na vybraném serveru vyberte BizTalkRuleEngineDb a pak vyberte Další.
Na stránce Exportovat zásady nebo slovník vyberte v seznamu Zásady požadovanou zásadu. Pokud chcete najít a zvolit definiční soubor, vyberte Procházet.
Až budete připraveni, vyberte Další.
Potvrďte informace o serveru, databázi a zásadách nebo slovníku a vyberte Další.
Po dokončení importu nebo exportu vyberte Další.
Zkontrolujte stav dokončení importu nebo exportu a vyberte Dokončit.

Vytvoření projektu azure Logic Apps Rules Engine

V editoru Visual Studio Code na panelu aktivit vyberte ikonu Azure. (Klávesnice: Shift+Alt+A)
V okně Azure , které se otevře, na panelu nástrojů oddílu Pracovní prostor v nabídce Azure Logic Apps vyberte Vytvořit nový pracovní prostor aplikace logiky.
V poli Vybrat složku přejděte do místní složky, kterou jste vytvořili pro svůj projekt, a vyberte ji.
Po zobrazení výzvy k vytvoření nového pracovního prostoru aplikace logiky zadejte název pracovního prostoru:

Tento příklad pokračuje s MyLogicAppRulesWorkspace.
Po zobrazení výzvy k výběru šablony projektu pro pracovní prostor aplikace logiky vyberte aplikaci logiky s projektem modulu pravidel (Preview).

Postupujte podle následujících výzev a zadejte následující ukázkové hodnoty:

Položka	Příklad hodnoty
Název funkce pro projekt funkcí	RulesFunction
Název oboru názvů pro projekt funkcí	Contoso.Enterprise
Šablona pracovního postupu: - Stavový pracovní postup - Bezstavové pracovní postupy	Stavový pracovní postup
Název pracovního postupu	MyRulesWorkflow

Vyberte Otevřít v aktuálním okně.

Po dokončení tohoto kroku Visual Studio Code vytvoří váš pracovní prostor, který obsahuje projekt funkcí a projekt modulu pravidel aplikace logiky, například:

Uzel	Popis
*<název pracovního prostoru>*	Obsahuje projekt funkcí i projekt pracovního postupu aplikace logiky.
Funkce	Obsahuje artefakty projektu funkce. Například *<název> funkce.cs* soubor kódu, kde můžete vytvořit kód.
LogicApp	Obsahuje artefakty pro projekt modulu pravidel aplikace logiky, včetně pracovního postupu.

Napsání kódu stroje pravidel

V pracovním prostoru rozbalte uzel Functions , pokud ještě není rozbalený.

<Otevřete soubor název> funkce.cs s názvem RulesFunction.cs v tomto příkladu.

Ve výchozím nastavení tento soubor obsahuje vzorový kód, který obsahuje následující prvky kódu spolu s dříve zadanými ukázkovými hodnotami tam, kde je to vhodné:

Název oboru názvů
Název třídy
Název funkce
Parametry funkce
Návratový typ
Komplexní typ

Následující příklad ukazuje kompletní vzorový kód funkce s názvem 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;}
        }
    }
}

Definice funkce obsahuje RulesFunction výchozí RunRules metodu, kterou můžete použít k zahájení práce. Tato ukázková RunRules metoda ukazuje, jak předat parametry do stroje pravidel Azure Logic Apps. V tomto příkladu metoda předá název sady pravidel, typ vstupního dokumentu, fakt XML a další hodnoty pro další zpracování.

Název <funkce>.cs soubor také obsahuje ILogger rozhraní, které poskytuje podporu protokolování událostí do prostředku Application Insights. Informace o trasování můžete odesílat do Application Insights a ukládat je spolu s informacemi o trasování z pracovních postupů, například:

private readonly ILogger<RulesFunction> logger;

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

Modul pravidel Azure Logic Apps funguje podle popisu v následujících krocích:

Modul používá FileStoreRuleExplorer objekt pro přístup ke sadě pravidel. Soubor sady pravidel je uložený v adresáři Pravidla pro vaši standardní aplikaci logiky.

V tomto příkladu se volá SampleRuleSet.xmlsoubor sady pravidel, který byl vytvořen pomocí nástroje Microsoft Rules Composer nebo exportován pomocí serveru 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.");
}
```
Důležité

Sady pravidel obsahují odkazy na jejich fakta. Microsoft Rules Composer hledá sestavení faktů k ověření sady pravidel pro úpravy. Chcete-li otevřít sady pravidel, například SampleRuleSet.xml v nástroji Microsoft Rules Composer, musíte je umístit s odpovídajícími sestaveními faktů .NET. V opačném případě se zobrazí výjimka.
Modul používá ruleSet objekt k vytvoření instance objektu RuleEngine .

Objekt RuleEngine obdrží fakta pravidla pomocí Execute metody.

V tomto příkladu Execute metoda obdrží dvě fakta: fakt XML pojmenovaný typedXmlDocument a fakt .NET s názvem currentPurchase.

Po spuštění modulu se hodnoty faktů přepíšou hodnotami, které jsou výsledkem provádění modulu:

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

Modul používá RuleExecutionResult vlastní třídu k vrácení hodnot do RunRules metody:

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

return Task.FromResult(ruleExecutionOutput);

Nahraďte vzorový kód funkce vlastními a upravte výchozí RunRules metodu pro vlastní scénáře.

Tento příklad pokračuje v používání vzorového kódu bez jakýchkoli změn.

Kompilace a sestavení kódu

Po napsání kódu se zkompilujte a ujistěte se, že neexistují žádné chyby sestavení. Projekt funkcí automaticky zahrnuje úlohy sestavení, které kompilují a pak přidávají všechny vlastní knihovny kódu, včetně sestavení faktů .NET, do složky lib\custom v projektu aplikace logiky, kde pracovní postupy hledají vlastní funkce ke spuštění. Tyto úlohy umístí sestavení do složky lib\custom\net472 .

V editoru Visual Studio Code v nabídce Terminál vyberte Nový terminál.
V seznamu pracovních adresářů, který se zobrazí, vyberte jako aktuální pracovní adresář pro nový terminál funkci Functions .

Visual Studio Code otevře okno terminálu s příkazovým řádkem.
V okně terminálu na příkazovém řádku zadejte dotnet restore .\RulesFunction.csproj.
Po opětovném zobrazení příkazového řádku zadejte dotnet build .\RulesFunction.csproj.

Pokud sestavení proběhne úspěšně, okno terminálu oznámí, že sestavení proběhlo úspěšně.
Ověřte, že v projektu aplikace logiky existují následující položky:
- V pracovním prostoru rozbalte následující složky: LogicApp>lib\custom>net472. Ověřte, že podsložka s názvem net472 obsahuje více sestavení potřebných ke spuštění kódu, včetně souboru s názvem< název> funkce.dll.
- V pracovním prostoru rozbalte následující složky: LogicApp>lib\custom<>function-name.> Ověřte, že podsložka s názvem <název funkce> obsahuje soubor function.json, který obsahuje metadata o kódu funkce, který jste napsali. Návrhář pracovního postupu používá tento soubor k určení potřebných vstupů a výstupů při volání kódu.
Následující příklad ukazuje ukázková vygenerovaná sestavení a další soubory v projektu aplikace logiky:

Volání pravidel z pracovního postupu

Po potvrzení, že se kód zkompiluje a že projekt modulu pravidel aplikace logiky obsahuje potřebné soubory pro spuštění kódu, otevřete výchozí pracovní postup, který je součástí projektu aplikace logiky.

V pracovním prostoru v části LogicApp rozbalte <uzel názvu> pracovního postupu, otevřete místní nabídku pro workflow.json a vyberte Otevřít Návrhář.

V návrháři pracovního postupu, který se otevře, se zobrazí výchozí pracovní postup zahrnutý v projektu aplikace logiky s následující aktivační událostí a akcemi:
- Předdefinovaný trigger požadavku s názvem Při přijetí požadavku HTTP.
- Integrovaná akce s názvem Volání funkce místních pravidel v této aplikaci logiky.
- Integrovaná akce Odpovědi s názvem Response ( Odpověď), kterou používáte k odpovídání volajícímu pouze při použití triggeru požadavku.
Vyberte akci s názvem Volání funkce místních pravidel v této aplikaci logiky.

Informační podokno akce se otevře na pravé straně.
Zkontrolujte a ověřte, že je hodnota parametru Název funkce nastavená na funkci pravidel, kterou chcete spustit. Zkontrolujte nebo změňte jakékoli jiné hodnoty parametrů, které vaše funkce používá.

Ladění kódu a pracovního postupu

Opakujte následující kroky a třikrát spusťte emulátor úložiště Azurite: jednou pro následující služby Azure Storage:
- Azure Blob Service
- Služba fronty Azure
- Azure Table Service
1. V nabídce Zobrazení editoru Visual Studio Code vyberte Paleta příkazů.
2. Na příkazovém řádku, který se zobrazí, vyhledejte a vyberte Azurite: Spustit službu Blob Service.
3. V seznamu pracovních adresářů, který se zobrazí, vyberte LogicApp.
4. Opakujte tento postup pro Azurite: Spustit službu fronty a Azurite: Start Table Service.
Po úspěšném spuštění hlavního panelu editoru Visual Studio Code v dolní části obrazovky se zobrazí tři spuštěné služby úložiště, například:
Na panelu aktivit editoru Visual Studio Code vyberte Spustit a Ladit. (Klávesnice: Ctrl+Shift+D)
V seznamu Spustit a ladit vyberte Připojit k aplikaci logiky (LogicApp), pokud ještě není vybraná, a pak vyberte Přehrát (zelená šipka).

Otevře se okno terminálu a zobrazí se spuštěný proces ladění. Zobrazí se okno konzoly ladění a zobrazí se stavy ladění. V dolní části editoru Visual Studio Code se hlavní panel změní na oranžovou, což znamená, že je načten ladicí program .NET.
V seznamu Spustit a ladit vyberte Připojit k funkcím .NET (Funkce) a pak vyberte Přehrát (zelená šipka).
Pokud chcete nastavit zarážky, najděte v definici funkce (<název> funkce.cs) nebo definici pracovního postupu (workflow.json), najděte číslo řádku, kde chcete zarážku, a vyberte sloupec na levou stranu, například:
Pokud chcete v pracovním postupu ručně spustit trigger požadavku, otevřete stránku Přehled pracovního postupu.
1. V projektu aplikace logiky otevřete místní nabídku workflow.json souboru a vyberte Přehled.
  
  Na stránce Přehled pracovního postupu je tlačítko Spustit trigger k dispozici, pokud chcete pracovní postup spustit ručně. V části Vlastnosti pracovního postupu je hodnota adresy URL zpětného volání pro volatelný koncový bod, který je vytvořen triggerem požadavku ve vašem pracovním postupu. Na tuto adresu URL můžete odesílat požadavky, které aktivují pracovní postup z jiných aplikací, včetně dalších pracovních postupů aplikace logiky.
Na panelu nástrojů stránky Přehled vyberte Aktivační událost spustit.

Jakmile se pracovní postup spustí, ladicí program aktivuje první zarážku.
V nabídce Spustit nebo panelu nástrojů ladicího programu vyberte akci ladění.

Po dokončení pracovního postupu se na stránce Přehled zobrazí dokončené spuštění a základní podrobnosti o tomto spuštění.
Pokud chcete zkontrolovat další informace o spuštění pracovního postupu, vyberte dokončené spuštění. Nebo v seznamu vedle sloupce Doba trvání vyberte Zobrazit spuštění.