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

Platí pro: Azure Logic Apps (Standard)

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 ukazuje, 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 zavést podnikání pro projekt pravidlového stroje, projděte si následující dokumentaci:
- Vytváření pravidel pomocí nástroje Microsoft Rules Composer
- Správa rozhodnutí a integrace obchodní logiky pomocí pravidlového engine 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ází však v současné době nejsou podporována. 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 Pravidlového nástroje vyberte Další.
Na stránce Úloha nasazení vyberte Exportovat zásady/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 svůj 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řit projekt 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 Logic Apps.
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 stroje pravidel.

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 Functions	Contoso
Aplikace logiky:	LogicApp
Š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:

Node	Popis
*< název pracovního prostoru>*	Obsahuje projekt funkcí i projekt pracovního postupu aplikace logiky.
Funkce	Obsahuje artefakty vašeho funkčního projektu. Například soubor *<název-funkce>.cs* je soubor kódu, ve kterém můžete psát svůj kód.
LogicApp	Obsahuje artefakty pro projekt modulu pravidel aplikace logiky, včetně pracovního postupu.

Píš svůj kód pravidlového stroje

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

<Otevřete soubor název funkce>.cs, který je pojmenován 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 namespace
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
{
     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;}
         }
     }
}

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 pravidelového enginu 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í.

< function-name>.cs soubor také zahrnuje ILogger rozhraní, které poskytuje podporu pro protokolování událostí do prostředku služby 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ů. Soubor <funkce>.cs také zahrnuje FileStoreRuleExplorer objekt, který přistupuje ke sadě pravidel. Jak můžete vidět, konstruktor pro FileStoreRuleExplorer používá loggerFactory také k odesílání telemetrických informací do Application Insights.

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

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

    <...>

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 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.");
}

Důležité

Sady pravidel obsahují odkazy na jejich fakta. Microsoft Rules Composer hledá sestavení faktů k ověření sady pravidel pro jejich úpravu. Chcete-li otevřít sady pravidel, například SampleRuleSet.xml v nástroji Microsoft Rules Composer, musíte je umístit společně 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 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;

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

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

             return Task.FromResult(ruleExectionOutput);

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ě .NET sestavení, do složky lib\custom ve vašem projektu Logic Apps, 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:

Vyvolejte svá pravidla 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 <workflow-name>, 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 Vyvolání funkce místních pravidel v této logické aplikaci.
- 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 Zavolat funkci místních pravidel v této logické aplikaci.

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
- Služba Azure Table
1. V nabídce Zobrazení editoru Visual Studio Code vyberte Příkazovou paletu.
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: Spustit službu tabulky.
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í. Ve Visual Studio Code dole se stavový řádek změní na oranžovou, což znamená, že je načten ladicí program .NET.
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 spouštěč požadavku, otevřete stránku Přehled pracovního postupu.
1. V projektu vaší logické aplikace otevřete místní nabídku souboru workflow.json 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 Callback URL adresou URL 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 Spustit spouštěč.

Jakmile se pracovní postup začne spouštět, ladicí program aktivuje první zarážku.
Na nabídce Spustit nebo v 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 si chcete prohlédnout více informací o běhu pracovního postupu, zvolte dokončený běh. Nebo v seznamu vedle sloupce Doba trvání vyberte Zobrazit spuštění.
Pokud chcete nasadit aplikace logiky pomocí projektu Modulu pravidel do Azure Logic Apps, postupujte podle kroků v části Příprava na nasazení.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-12