Tworzenie projektu aparatu reguł usługi Azure Logic Apps przy użyciu programu Visual Studio Code (wersja zapoznawcza)

Artykuł
06/13/2024

Dotyczy: Azure Logic Apps (Standardowa)

Ważne

Ta funkcja jest dostępna w wersji zapoznawczej i podlega dodatkowym warunkom użytkowania wersji zapoznawczej platformy Microsoft Azure.

Jeśli chcesz zintegrować logikę biznesową z przepływami pracy w warstwie Standardowa w usłudze Azure Logic Apps, możesz utworzyć i utworzyć projekt aparatu reguł usługi Azure Logic Apps przy użyciu programu Visual Studio Code. Reguły określają logikę biznesową pod kątem sposobu działania procesów biznesowych.

W tym przewodniku z instrukcjami opisano sposób tworzenia projektu aparatu reguł usługi Azure Logic Apps:

Wymagania wstępne i konfiguracja tworzenia projektu aparatu reguł usługi Azure Logic Apps, w tym tworzenie reguł biznesowych dla projektu za pomocą narzędzia Microsoft Rules Composer.
Wyeksportuj istniejące reguły z programu Microsoft BizTalk Server, jeśli istnieją.
Utwórz standardowy projekt aplikacji logiki dla aparatu reguł usługi Azure Logic Apps przy użyciu programu Visual Studio Code.

Wymagania wstępne

Pobierz i zainstaluj program Microsoft Rules Composer, który służy do tworzenia zestawów reguł, reguł biznesowych i słownictwa.

Aby utworzyć firmę dla projektu aparatu reguł, zapoznaj się z następującą dokumentacją:
- Tworzenie reguł za pomocą narzędzia Microsoft Rules Composer
- Zarządzanie decyzjami i integracja logiki biznesowej przy użyciu aparatu reguł usługi Azure Logic Apps
W tej wersji tylko program Visual Studio Code obsługuje środowisko programistyczne dla projektu aparatu reguł usługi Azure Logic Apps. Aby spełnić wymagania wstępne dotyczące korzystania z programu Visual Studio Code, zobacz Tworzenie standardowego przepływu pracy aplikacji logiki w usłudze Azure Logic Apps z jedną dzierżawą przy użyciu programu Visual Studio Code.
Aparat reguł usługi Azure Logic Apps używa niestandardowej funkcji kodu w programie Visual Studio Code. Aby spełnić wymagania wstępne dotyczące korzystania z tej funkcji, zobacz Tworzenie i uruchamianie kodu programu .NET Framework z przepływów pracy w warstwie Standardowa w usłudze Azure Logic Apps.

Przed utworzeniem projektu

Aby ułatwić zapewnienie pomyślnego projektu aparatu reguł, przejrzyj i wykonaj następujące ogólne zadania i najlepsze rozwiązania:

Określanie sposobu dopasowania reguł biznesowych do procesów biznesowych.
Planowanie sposobu dołączania reguł biznesowych do aplikacji.
Zidentyfikuj logikę biznesową, którą chcesz reprezentować za pomocą reguł w aplikacji.

Termin "logika biznesowa" może odnosić się do wielu rzeczy. Na przykład logika biznesowa może mieć wartość "Zamówienia zakupu większe niż 500 dolarów wymagają zatwierdzenia przez menedżera".
Identyfikowanie źródeł danych dla elementów reguły. Opcjonalnie można zdefiniować słownictwo, które są nomenklaturą specyficzną dla domeny, która reprezentuje powiązania bazowe.
Zdefiniuj reguły używane z definicji słownictwa lub bezpośrednio z powiązań danych. Na podstawie tych reguł utwórz zestaw reguł reprezentujący logikę biznesową.

Eksportowanie reguł z programu Microsoft BizTalk Server

Aby ponownie użyć istniejących reguł z programu Microsoft BizTalk Server, możesz je wyeksportować. Jednak fakty bazy danych nie są obecnie obsługiwane. Przed wyeksportowanie reguł usuń lub refaktoryzuj je do innych typów faktów przy użyciu narzędzia Microsoft BizTalk Rules Composer.

W programie Microsoft BizTalk Server uruchom Kreatora wdrażania aparatu reguł biznesowych.
Na stronie Kreator wdrażania aparatu reguł kliknij przycisk Dalej.
Na stronie Zadanie wdrożenia wybierz pozycję Eksportuj zasady/Słownictwo do pliku z bazy danych, a następnie wybierz pozycję Dalej.
Na stronie Magazyn zasad na liście Nazwa programu SQL Server wybierz serwer SQL. Na liście Baza danych konfiguracji na wybranym serwerze wybierz pozycję BizTalkRuleEngineDb, a następnie wybierz pozycję Dalej.
Na stronie Eksportowanie zasad/słownictwa z listy Zasady wybierz żądane zasady. Aby znaleźć i wybrać plik definicji, wybierz pozycję Przeglądaj.
Gdy wszystko będzie gotowe, wybierz pozycję Dalej.
Potwierdź informacje o serwerze, bazie danych i zasadach lub słownictwie, a następnie wybierz pozycję Dalej.
Po zakończeniu importowania lub eksportowania wybierz pozycję Dalej.
Przejrzyj stan ukończenia importowania lub eksportu, a następnie wybierz pozycję Zakończ.

Tworzenie projektu aparatu reguł usługi Azure Logic Apps

W programie Visual Studio Code na pasku działań wybierz ikonę platformy Azure . (Klawiatura: Shift+Alt+A)
W wyświetlonym oknie platformy Azure na pasku narzędzi sekcji Obszar roboczy z menu Azure Logic Apps wybierz pozycję Utwórz nowy obszar roboczy aplikacji logiki.
W polu Wybierz folder przejdź do folderu lokalnego utworzonego dla projektu i wybierz go.
Po wyświetleniu okna monitu Tworzenie nowego obszaru roboczego aplikacji logiki podaj nazwę obszaru roboczego:

W tym przykładzie jest kontynuowana praca z aplikacją MyLogicAppRulesWorkspace.
Po wyświetleniu okna monitu Wybierz szablon projektu dla obszaru roboczego aplikacji logiki wybierz pozycję Aplikacja logiki z projektem aparatu reguł (wersja zapoznawcza).

Postępuj zgodnie z kolejnymi monitami, aby podać następujące przykładowe wartości:

Towar	Przykładowa wartość
Nazwa funkcji projektu funkcji	RegułyFunction
Nazwa przestrzeni nazw projektu funkcji	Contoso.Enterprise
Szablon przepływu pracy: - Stanowy przepływ pracy - Przepływ pracy bezstanowy	Stanowy przepływ pracy
Nazwa przepływu pracy	MyRulesWorkflow

Wybierz pozycję Otwórz w bieżącym oknie.

Po zakończeniu tego kroku program Visual Studio Code tworzy obszar roboczy, który obejmuje projekt funkcji i projekt aparatu reguł aplikacji logiki, na przykład:

Węzeł	opis
*<nazwa obszaru roboczego>*	Zawiera zarówno projekt funkcji, jak i projekt przepływu pracy aplikacji logiki.
Funkcja	Zawiera artefakty projektu funkcji. Na przykład *<plik nazwa-funkcji>.cs* to plik kodu, w którym można utworzyć kod.
LogicApp	Zawiera artefakty projektu aparatu reguł aplikacji logiki, w tym przepływ pracy.

Pisanie kodu aparatu reguł

W obszarze roboczym rozwiń węzeł Funkcje , jeśli jeszcze nie został rozszerzony.

<Otwórz plik function-name>.cs o nazwie RulesFunction.cs w tym przykładzie.

Domyślnie ten plik zawiera przykładowy kod, który zawiera następujące elementy kodu wraz z wcześniej podanymi przykładowymi wartościami w odpowiednich przypadkach:

Nazwa przestrzeni nazw
Nazwa klasy
Nazwa funkcji
Parametry funkcji
Typ zwracany
Typ złożony

W poniższym przykładzie przedstawiono kompletny przykładowy kod funkcji o nazwie 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 typedXmlDcoument 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 ruleExectionOutput = new RuleExecutionResult()
                {
                    XmlDoc = updatedDoc.OuterXml,
                    PurchaseAmountPostTax = currentPurchase.PurchaseAmount + currentPurchase.GetSalesTax()
                };

                return Task.FromResult(ruleExectionOutput);
            }
            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;}
        }
    }
}

Definicja funkcji dla RulesFunction programu zawiera domyślną RunRules metodę, której można użyć do rozpoczęcia pracy. Ta przykładowa RunRules metoda pokazuje, jak przekazać parametry do aparatu reguł usługi Azure Logic Apps. W tym przykładzie metoda przekazuje nazwę zestawu reguł, typ dokumentu wejściowego, fakt XML i inne wartości do dalszego przetwarzania.

Plik <nazwa-funkcji>.cs zawiera ILogger również interfejs, który zapewnia obsługę rejestrowania zdarzeń do zasobu usługi Application Insights. Możesz wysyłać informacje śledzenia do usługi Application Insights i przechowywać te informacje wraz z informacjami śledzenia z przepływów pracy, na przykład:

private readonly ILogger<RulesFunction> logger;

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

Aparat reguł usługi Azure Logic Apps działa zgodnie z opisem w następujących krokach:

Aparat używa FileStoreRuleExplorer obiektu w celu uzyskania dostępu do zestawu reguł. Plik zestawu reguł jest przechowywany w katalogu Reguły dla standardowej aplikacji logiki.

W tym przykładzie plik zestawu reguł nosi nazwę SampleRuleSet.xml, która została utworzona przy użyciu narzędzia Microsoft Rules Composer lub wyeksportowanego przy użyciu programu 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.");
}
```
Ważne

Zestawy reguł przechowują odniesienia do ich faktów. Narzędzie Microsoft Rules Composer szuka zestawów faktów w celu zweryfikowania zestawu reguł do edycji. Aby otworzyć zestawy reguł, takie jak SampleRuleSet.xml w narzędziu Microsoft Rules Composer, należy umieścić je przy użyciu odpowiednich zestawów faktów platformy .NET. W przeciwnym razie otrzymasz wyjątek.
Aparat używa ruleSet obiektu do utworzenia RuleEngine wystąpienia obiektu.

Obiekt RuleEngine odbiera fakty reguły przy użyciu Execute metody .

W tym przykładzie Execute metoda otrzymuje dwa fakty: fakt XML o nazwie i fakt platformy .NET o nazwie typedXmlDocument currentPurchase.

Po uruchomieniu aparatu wartości faktów są zastępowane wartościami wynikowymi z wykonania aparatu:

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

Aparat używa klasy niestandardowej RuleExecutionResult , aby zwrócić wartości do RunRules metody:

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

return Task.FromResult(ruleExectionOutput);

Zastąp przykładowy kod funkcji własnym kodem i zmodyfikuj domyślną RunRules metodę dla własnych scenariuszy.

W tym przykładzie nadal używasz przykładowego kodu bez żadnych zmian.

Kompilowanie i kompilowanie kodu

Po zakończeniu pisania kodu skompiluj, aby upewnić się, że nie istnieją żadne błędy kompilacji. Projekt funkcji automatycznie uwzględnia zadania kompilacji, które kompilują, a następnie dodają dowolne niestandardowe biblioteki kodu, w tym zestawy faktów platformy .NET, do folderu lib\custom w projekcie aplikacji logiki, w którym przepływy pracy szukają funkcji niestandardowych do uruchomienia. Te zadania umieszczają zestawy w folderze lib\custom\net472 .

W programie Visual Studio Code z menu Terminal wybierz pozycję Nowy terminal.
Z wyświetlonej listy katalogów roboczych wybierz pozycję Funkcje jako bieżący katalog roboczy dla nowego terminalu.

Program Visual Studio Code otwiera okno terminalu z wierszem polecenia.
W oknie Terminal w wierszu polecenia wprowadź ciąg dotnet restore .\RulesFunction.csproj.
Po ponownym wyświetleniu wiersza polecenia wprowadź ciąg dotnet build .\RulesFunction.csproj.

Jeśli kompilacja zakończy się pomyślnie, okno terminalu zgłosi, że kompilacja zakończyła się pomyślnie.
Upewnij się, że w projekcie aplikacji logiki istnieją następujące elementy:
- W obszarze roboczym rozwiń następujące foldery: LogicApp>lib\custom>net472. Upewnij się, że podfolder o nazwie net472 zawiera wiele zestawów wymaganych do uruchomienia kodu, w tym plik o nazwie< nazwa-funkcji>.dll.
- W obszarze roboczym rozwiń następujące foldery: LogicApp>lib\custom<>function-name.> Upewnij się, że podfolder o nazwie <function-name> zawiera plik function.json zawierający metadane dotyczące napisanego kodu funkcji. Projektant przepływu pracy używa tego pliku do określenia niezbędnych danych wejściowych i wyjściowych podczas wywoływania kodu.
W poniższym przykładzie pokazano przykładowe wygenerowane zestawy i inne pliki w projekcie aplikacji logiki:

Wywoływanie reguł z przepływu pracy

Po potwierdzeniu, że kod zostanie skompilowany i że projekt aparatu reguł aplikacji logiki zawiera pliki niezbędne do uruchomienia kodu, otwórz domyślny przepływ pracy dołączony do projektu aplikacji logiki.

W obszarze roboczym w obszarze LogicApp rozwiń <węzeł nazwa> przepływu pracy, otwórz menu skrótów dla workflow.json, a następnie wybierz pozycję Otwórz projektanta.

W wyświetlonym projektancie przepływu pracy domyślny przepływ pracy dołączony do projektu aplikacji logiki jest wyświetlany z następującym wyzwalaczem i akcjami:
- Wbudowany wyzwalacz żądania o nazwie Po odebraniu żądania HTTP.
- Wbudowana akcja o nazwie Wywołaj funkcję reguł lokalnych w tej aplikacji logiki.
- Wbudowana akcja Odpowiedź o nazwie Odpowiedź, która służy do odpowiadania na obiekt wywołujący tylko wtedy, gdy używasz wyzwalacza Żądania.
Wybierz akcję o nazwie Wywołaj funkcję reguł lokalnych w tej aplikacji logiki.

Okienko informacji o akcji zostanie otwarte po prawej stronie.
Przejrzyj i upewnij się, że wartość parametru Nazwa funkcji jest ustawiona na funkcję reguł, którą chcesz uruchomić. Przejrzyj lub zmień inne wartości parametrów używane przez funkcję.

Debugowanie kodu i przepływu pracy

Powtórz następujące kroki, aby uruchomić emulator magazynu Azurite trzy razy: jeden raz dla następujących usług Azure Storage:
- Azure Blob Service
- Usługa kolejek systemu Azure
- Azure Table Service
1. Z menu Widok programu Visual Studio Code wybierz pozycję Paleta poleceń.
2. Po wyświetleniu monitu znajdź i wybierz pozycję Azurite: Uruchom usługę Blob Service.
3. Z wyświetlonej listy katalogów roboczych wybierz pozycję LogicApp.
4. Powtórz następujące kroki dla usługi Azurite: Uruchom usługę Kolejki i Azurite: Uruchom usługę Table Service.
Po pomyślnym zakończeniu działania paska zadań programu Visual Studio Code w dolnej części ekranu są wyświetlane trzy uruchomione usługi magazynu, na przykład:
Na pasku działań programu Visual Studio Code wybierz pozycję Uruchom i debuguj. (Klawiatura: Ctrl+Shift+D)
Z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do aplikacji logiki (LogicApp), jeśli nie została jeszcze wybrana, a następnie wybierz pozycję Odtwórz (zielona strzałka).

Zostanie otwarte okno Terminal i zostanie wyświetlone rozpoczęty proces debugowania. Zostanie wyświetlone okno Konsola debugowania i zostanie wyświetlone stany debugowania. W dolnej części programu Visual Studio Code pasek zadań zmieni kolor pomarańczowy, co oznacza, że debuger platformy .NET jest ładowany.
Z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do funkcji platformy .NET (Funkcje), a następnie wybierz pozycję Odtwórz (zielona strzałka).
Aby ustawić wszystkie punkty przerwania, w definicji funkcji (<nazwa-funkcji>.cs) lub definicji przepływu pracy (workflow.json), znajdź numer wiersza, w którym chcesz punkt przerwania, a następnie wybierz kolumnę po lewej stronie, na przykład:
Aby ręcznie uruchomić wyzwalacz żądania w przepływie pracy, otwórz stronę Przegląd przepływu pracy.
1. W projekcie aplikacji logiki otwórz menu skrótów pliku workflow.json i wybierz pozycję Przegląd.
  
  Na stronie Przegląd przepływu pracy przycisk Uruchom wyzwalacz jest dostępny, gdy chcesz ręcznie uruchomić przepływ pracy. W obszarze Właściwości przepływu pracy wartość adresu URL wywołania zwrotnego to adres URL punktu końcowego z możliwością wywołania, który jest tworzony przez wyzwalacz Żądania w przepływie pracy. Możesz wysyłać żądania do tego adresu URL w celu wyzwolenia przepływu pracy z innych aplikacji, w tym innych przepływów pracy aplikacji logiki.
Na pasku narzędzi strony Przegląd wybierz pozycję Uruchom wyzwalacz.

Po uruchomieniu przepływu pracy debuger aktywuje swój pierwszy punkt przerwania.
Na pasku narzędzi Uruchom menu lub debugera wybierz akcję debugowania.

Po zakończeniu przebiegu przepływu pracy na stronie Przegląd zostanie wyświetlony ukończony przebieg i podstawowe informacje o tym przebiegu.
Aby przejrzeć więcej informacji na temat przebiegu przepływu pracy, wybierz ukończone uruchomienie. Lub z listy obok kolumny Czas trwania wybierz pozycję Pokaż przebieg.