Erstellen eines Azure Logic Apps-Regel-Engine-Projekts mit Visual Studio Code (Vorschau)

Artikel
01/27/2025

Gilt für: Azure Logic Apps (Standard)

Wichtig

Diese Funktion befindet sich in der Vorschauphase und unterliegt den Zusätzlichen Nutzungsbedingungen für Microsoft Azure-Vorschauversionen.

Wenn Sie Geschäftslogik in Ihre Standardworkflows in Azure Logic Apps integrieren möchten, können Sie mit Visual Studio Code ein Azure Logic Apps-Regel-Engine-Projekt erstellen. Regeln steuern die Geschäftslogik für die Ausführung von Geschäftsprozessen.

In dieser Schrittanleitung erfahren Sie, wie Sie ein Azure Logic Apps-Regel-Engine-Projekt erstellen:

Voraussetzungen und Setup für das Erstellen Ihres Azure Logic Apps-Regel-Engine-Projekts, einschließlich der Erstellung der Geschäftsregeln für Ihr Projekt mit Microsoft Rules Composer
Exportieren Sie ggf. vorhandene Regeln aus Microsoft BizTalk Server.
Erstellen Sie mit Visual Studio Code ein Standard-Logic Apps-Projekt für die Azure Logic Apps-Regel-Engine.

Voraussetzungen

Laden Sie Microsoft Rules Composer herunter, den Sie zum Erstellen von Regelsätzen, Geschäftsregeln und Vokabularen verwenden, und installieren Sie das Programm.

Weitere Informationen zum Erstellen der Geschäftslogik für Ihr Regel-Engine-Projekt finden Sie in der folgenden Dokumentation:
- Erstellen von Regeln mit Microsoft Rules Composer
- Integration von Entscheidungsverwaltung und Geschäftslogik mithilfe der Azure Logic Apps-Regel-Engine
Bei diesem Release unterstützt nur Visual Studio Code die Entwicklungsumgebung für ein Azure Logic Apps-Regel-Engine-Projekt. Weitere Informationen zur Erfüllung der Voraussetzungen für die Verwendung von Visual Studio Code finden Sie unter Erstellen eines Standard-Logic Apps-Workflows in Azure Logic Apps für Einzelmandanten mit Visual Studio Code.
Die Azure Logic Apps-Regel-Engine verwendet die Funktionen für benutzerdefinierten Code in Visual Studio Code. Weitere Informationen zur Erfüllung der Voraussetzungen für die Verwendung dieser Funktion finden Sie unter Erstellen und Ausführen von .NET Framework-Code aus Standardworkflows in Azure Logic Apps.

Bevor Sie Ihr Projekt erstellen

Um ein erfolgreiches Regel-Engine-Projekt sicherzustellen, führen Sie die folgenden allgemeinen Aufgaben und bewährten Methoden aus:

Bestimmen Sie, wie sich die Geschäftsregeln in Ihre Geschäftsprozesse einfügen.
Planen Sie, wie Sie Geschäftsregeln in die Anwendung integrieren.
Identifizieren Sie die Geschäftslogik, die in der Anwendung durch Regeln dargestellt werden soll.

Der Begriff „Geschäftslogik“ kann sich auf viele Dinge beziehen. Beispielsweise kann eine Geschäftslogik „Für Bestellungen über 500 Dollar eine Genehmigung durch Vorgesetzte erzwingen“ lauten.
Identifizieren Sie Datenquellen für die Regelelemente. Sie können auch Vokabulare definieren, die domänenspezifische Terminologie für die zugrunde liegenden Bindungen repräsentiert.
Definieren Sie die anzuwendenden Regeln aus den Vokabulardefinitionen oder direkt aus Datenbindungen. Erstellen Sie aus diesen Regeln ein Regelsatz, der Ihre Geschäftslogik darstellt.

Exportieren von Regeln aus Microsoft BizTalk Server

Um vorhandene Regeln aus Microsoft BizTalk Server wiederzuverwenden, können Sie sie exportieren. Datenbankfakten werden derzeit jedoch nicht unterstützt. Bevor Sie Ihre Regeln exportieren, müssen Sie diese mithilfe von Microsoft BizTalk Rules Composer entfernen oder in andere Faktentypen umgestalten.

Starten Sie in Microsoft BizTalk Server den Assistenten für die Bereitstellung von Geschäftsregel-Engines.
Wählen Sie auf der Seite Willkommen die Option Weiter aus.
Wählen Sie auf der Seite Bereitstellungsaufgabe die Option Richtlinie/Vokabular aus einer Datei in eine Datenbank exportieren und dann Weiter aus.
Wählen Sie auf der Seite Richtlinienspeicher in der Liste SQL Server-Name Ihren SQL Server aus. Wählen Sie in der Konfigurationsdatenbank in der ausgewählten Serverliste BizTalkRuleEngineDb und dann Weiter aus.
Wählen Sie auf der Seite Richtlinie/Vokabular exportieren in der Liste Richtlinie die gewünschte Richtlinie aus. Um die Definitionsdatei zu suchen und auszuwählen, wählen Sie Durchsuchen aus.
Klicken Sie abschließend auf Weiter.
Überprüfen Sie die Informationen zu Server, Datenbank und Richtlinie oder Vokabular, und wählen Sie Weiter aus.
Wählen Sie nach dem Abschluss von Import oder Export Weiter aus.
Überprüfen Sie den Abschlussstatus des Import- bzw. Exportvorgangs, und wählen Sie dann auf Fertig stellen aus.

Erstellen eines Azure Logic Apps-Regel-Engine-Projekts

Wählen Sie auf der Aktivitätsleiste in Visual Studio Code das Azure-Symbol aus. (Tastatur: UMSCHALT+ALT+A)
Wählen Sie im dadurch geöffneten Fenster Azure auf der Symbolleiste des Abschnitts Arbeitsbereich im Menü Azure Logic Apps die Option Neuen Logik-App-Arbeitsbereich erstellen aus.
Navigieren Sie im Feld Ordner auswählen zum lokalen Ordner, den Sie für Ihr Projekt erstellt haben.
Wenn das Eingabeaufforderungsfeld Erstellen eines neuen Logik-App-Arbeitsbereichs angezeigt wird, geben Sie einen Namen für Ihren Arbeitsbereich ein:

Dieses Beispiel wird mit MyLogicAppRulesWorkspace fortgesetzt.
Wenn das Eingabeaufforderungsfeld Vorlage für Logik-App-Arbeitsbereich auswählen angezeigt wird, wählen Sie Logik-App mit Regel-Engine-Projekt (Vorschau) aus.

Geben Sie anhand der nachfolgenden Eingabeaufforderungen die folgenden Informationen an:

Artikel	Beispielswert
Funktionsname für Funktionsprojekt	RulesFunction
Namespacename für Funktionsprojekt	Contoso.Enterprise
Workflowvorlage: - Zustandsbehafteter Workflow - Zustandsloser Workflow	Zustandsbehafteter Workflow
Workflowname	MyRulesWorkflow

Wählen Sie In aktuellem Fenster öffnen aus.

Nachdem Sie diesen Schritt abgeschlossen haben, erstellt Visual Studio Code Ihren Arbeitsbereich, der standardmäßig ein Funktionsprojekt und ein Logik-App-Regel-Engine-Projekt enthält, z. B.:

Knoten	BESCHREIBUNG
*<arbeitsbereichname>*	Enthält sowohl Ihr Funktionsprojekt als auch Ihr Logik-App-Workflowprojekt.
Funktion	Enthält die Artefakte für Ihr Funktionsprojekt. Beispielsweise ist die Datei *<funktionsname>.cs* die Codedatei, in der Sie Ihren Code erstellen können.
LogicApp	Enthält die Artefakte für Ihr Logik-App-Regel-Engine-Projekt, einschließlich eines Workflows.

Schreiben des Codes für die Regel-Engine

Erweitern Sie in Ihrem Arbeitsbereich den Knoten Funktionen, falls dieser noch nicht erweitert ist.

Öffnen Sie die Datei <funktionsname>.cs (in diesem Beispiel RulesFunction.cs).

Standardmäßig enthält diese Datei Beispielcode, der die folgenden Codeelemente sowie ggf. die zuvor bereitgestellten Beispielwerte enthält:

Namespacename
Klassenname
Funktionsname
Funktionsparameter
Rückgabetyp
Komplexer Typ

Das folgende Beispiel zeigt den vollständigen Beispielcode für die Funktion mit dem Namen 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;}
        }
    }
}

Die Funktionsdefinition für RulesFunction enthält eine RunRules-Standardmethode, die Sie für die ersten Schritte verwenden können. Diese RunRules-Beispielmethode zeigt, wie Parameter an die Azure Logic Apps-Regel-Engine übergeben werden. In diesem Beispiel übergibt die Methode den Regelsatznamen, den Eingabedokumenttyp, einen XML-Fakt und noch andere Werte für die weitere Verarbeitung.

Die Datei <function-name>.cs enthält außerdem die ILogger-Schnittstelle, die Unterstützung für die Protokollierung von Ereignissen einer Application Insights-Ressource bietet. Sie können Ablaufverfolgungsinformationen an Application Insights senden und diese Informationen zusammen mit den Ablaufverfolgungsinformationen aus Ihren Workflows speichern, z. B.:

private readonly ILogger<RulesFunction> logger;

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

Die Azure Logic Apps-Regel-Engine funktioniert wie in den folgenden Schritten beschrieben:

Die Engine verwendet das FileStoreRuleExplorer-Objekt, um auf den Regelsatz zuzugreifen. Die Regelsatzdatei wird im Verzeichnis Rules für Ihre Standard-Logik-App gespeichert.

In diesem Beispiel hat die Regelsatzdatei die Bezeichnung SampleRuleSet.xml und wurde entweder mit Microsoft Rules Composer erstellt oder mit Microsoft BizTalk Server exportiert.
```
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.");
}
```
Wichtig

Regelsätze enthalten Verweise auf ihre Fakten. Microsoft Rules Composer sucht nach den Assemblys der Fakten, um das Regelset für die Bearbeitung zu validieren. Zum Öffnen von Regelsätzen wie SampleRuleSet.xml in Microsoft Rules Composer müssen Sie sie zusammen mit den zugehörigen .NET-Faktenassemblys speichern. Andernfalls wird eine Ausnahme ausgelöst.
Die Engine verwendet das ruleSet-Objekt, um eine Instanz des RuleEngine-Objekts zu erstellen.

Das RuleEngine-Objekt empfängt die Fakten der Regel mit der Execute-Methode.

In diesem Beispiel empfängt die Execute-Methode zwei Fakten: einen XML-Fakt namens typedXmlDocument und einen .NET-Fakt namens currentPurchase.

Nachdem die Engine ausgeführt wurde, werden die Faktenwerte mit den Werten überschrieben, die sich aus der Engine-Ausführung ergeben:

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

Das Modul verwendet die benutzerdefinierte RuleExecutionResult-Klasse, um die Werte an die RunRules-Methode zurückzugeben:

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

return Task.FromResult(ruleExecutionOutput);

Ersetzen Sie den Beispielfunktionscode durch Ihren eigenen, und bearbeiten Sie die RunRules-Standardmethode für Ihre eigenen Szenarien.

In diesem Beispiel wird der Beispielcode weiterhin ohne Änderungen genutzt.

Kompilieren und Erstellen Ihres Codes

Nachdem Sie das Schreiben des Codes abgeschlossen haben, kompilieren Sie ihn, um sicherzustellen, dass keine Buildfehler vorhanden sind. Ihr Funktionsprojekt enthält automatisch Buildaufgaben, die Ihre benutzerdefinierten Codebibliotheken, einschließlich Ihrer .NET-Faktenassemblys, kompilieren und dann im Ordner lib\custom in Ihrem Logik-App-Projekt hinzufügen. In diesem Ordner suchen Workflows nach benutzerdefinierten Funktionen, die ausgeführt werden sollen. Diese Aufgaben legen die Assemblys im Ordner lib\custom\net472 ab.

Wählen Sie in Visual Studio Code im Menü Terminal die Option Neues Terminal aus.
Wählen Sie in der angezeigten Arbeitsverzeichnisliste Funktionen als aktuelles Arbeitsverzeichnis für das neue Terminal aus.

Visual Studio Code öffnet ein Terminalfenster mit einer Eingabeaufforderung.
Geben Sie im Terminalfenster an der Eingabeaufforderung dotnet restore .\RulesFunction.csproj ein.
Wenn die Eingabeaufforderung wieder angezeigt wird, geben Sie dotnet build .\RulesFunction.csproj ein.

Wenn Ihr Build erfolgreich ist, wird im Terminalfenster die Meldung Build erfolgreich ausgegeben.
Vergewissern Sie sich, dass die folgenden Elemente in Ihrem Logik-App-Projekt vorhanden sind:
- Erweitern Sie in Ihrem Arbeitsbereich die folgenden Ordner: LogicApp>lib\custom>net472. Vergewissern Sie sich, dass der Unterordner net472 die verschiedenen Assemblys enthält, die zum Ausführen des Codes erforderlich sind, einschließlich einer Datei namens <funktionsname>.dll.
- Erweitern Sie in Ihrem Arbeitsbereich die folgenden Ordner: LogicApp>lib\custom><function-name>. Vergewissern Sie sich, dass der Unterordner <function-name> eine Datei namensfunction.json enthält, die die Metadaten für den von Ihnen geschriebenen Funktionscode enthält. Der Workflow-Designer verwendet diese Datei, um die erforderlichen Eingaben und Ausgaben zu bestimmen, wenn Ihr Code aufgerufen wird.
Das folgende Beispiel zeigt generierte Assemblys und andere Dateien im Logik-App-Projekt:

Aufrufen Ihrer Regeln aus einem Workflow

Nachdem Sie sich vergewissert haben, dass Ihr Code kompiliert wird und dass Ihr Logik-App-Regel-Engine-Projekt die erforderlichen Dateien für die Ausführung Ihres Codes enthält, öffnen Sie den Standardworkflow, der in Ihrem Logik-App-Projekt enthalten ist.

Erweitern Sie in Ihrem Arbeitsbereich unter LogicApp den Knoten <workflowname>, öffnen Sie das Kontextmenü für workflow.json, und wählen Sie Designer öffnen aus.

Im Workflow-Designer, der geöffnet wird, wird der Standardworkflow, der in Ihrem Logik-App-Projekt enthalten ist, mit dem folgenden Trigger und den folgenden Aktionen angezeigt:
- Dem integrierten Anforderungstrigger namens Beim Empfang einer HTTP-Anforderung
- Der integrierten Aktion namens Lokale Funktion in dieser Logik-App aufrufen
- Der integrierten Antwortaktion namens Antwort, mit der Sie dem Aufrufer nur antworten, wenn Sie den Anforderungstrigger verwenden
Wählen Sie die Aktion namens Lokale Funktion in dieser Logik-App aufrufen aus.

Der Informationsbereich der Aktion wird auf der rechten Seite geöffnet.
Überprüfen Sie, ob der Parameterwert Funktionsname auf die auszuführende Regelfunktion festgelegt ist. Überprüfen oder ändern Sie alle anderen Parameterwerte, die ihre Funktion verwendet.

Debuggen von Code und Workflow

Wiederholen Sie die folgenden Schritte, um den Azurite-Speicheremulator drei Mal zu starten: jeweils ein Mal für die folgenden Azure Storage-Dienste:
- Azure-Blob-Dienst
- Azure Queue Service
- Azure-Tabellendienst
1. Wählen Sie in Visual Studio Code im Menü Ansicht die Option Befehlspalette aus.
2. Suchen Sie an der angezeigten Eingabeaufforderung nach Azurite: Blobdienst starten, und wählen Sie diese Option aus.
3. Wählen Sie in der angezeigten Arbeitsverzeichnisliste LogicApp aus.
4. Wiederholen Sie diese Schritte für Azurite: Warteschlangendienst starten und Azurite: Tabellendienst starten.
Sie sind erfolgreich, wenn die Taskleiste von Visual Studio Code unten auf dem Bildschirm die drei ausgeführten Speicherdienste anzeigt, z. B.:
Wählen Sie auf der Aktivitätsleiste von Visual Studio Code Ausführen und Debuggen aus. (Tastenkombination: STRG+UMSCHALT+D)
Wählen Sie in der Liste Ausführen und Debuggen die Option An Logik-App anfügen (LogicApp) aus, falls nicht bereits ausgewählt, und wählen Sie dann Wiedergeben (grüner Pfeil) aus.

Das Terminalfenster wird geöffnet und zeigt den gestarteten Debugprozess an. Anschließend wird das Fenster Debugkonsole angezeigt, in dem die Debugstatus angezeigt werden. Unten in Visual Studio Code färbt sich die Taskleiste orange und zeigt damit an, dass der .NET-Debugger geladen ist.
Wählen Sie in der Liste Ausführen und Debuggen die Option An .NET Functions anfügen (Functions) und dann Wiedergeben (grüner Pfeil) aus.
Um Haltepunkte festzulegen, suchen Sie in Ihrer Funktionsdefinition (<funktionsname>.cs) oder Workflowdefinition (workflow.json) nach der Zeilennummer, an der Sie den Haltepunkt verwenden möchten, und wählen Sie die Spalte auf der linken Seite aus, z. B.:
Um den Anforderungstrigger in Ihrem Workflow manuell auszuführen, öffnen Sie die Seite Übersicht des Workflows.
1. Öffnen Sie in Ihrem Logik-App-Projekt das Kontextmenü der Datei workflow.json, und wählen Sie Übersicht aus.
  
  Auf der Seite Übersicht des Workflows ist die Schaltfläche Trigger ausführen verfügbar, wenn Sie den Workflow manuell starten möchten. Unter Workfloweigenschaften ist der Wert der Rückruf-URL die URL für einen aufrufbaren Endpunkt, der vom Anforderungstrigger in Ihrem Workflow erstellt wird. Sie können Anforderungen an diese URL senden, um Ihren Workflow aus anderen Apps auszulösen, einschließlich anderer Logik-App-Workflows.
Wählen Sie in der Symbolleiste der Seite Übersicht die Option Trigger ausführen aus.

Nachdem der Workflow mit der Ausführung begonnen hat, aktiviert der Debugger Ihren ersten Breakpoint.
Wählen Sie im Menü Ausführen oder in der Symbolleiste des Debuggers eine Debugaktion aus.

Nach Abschluss der Workflowausführung werden auf der Seite Übersicht die fertige Ausführung und grundlegende Details zu dieser Ausführung angezeigt.
Wählen Sie die beendete Ausführung aus, um weitere Informationen zur Workflowausführung zu überprüfen. Sie können auch in der Liste neben der Spalte Dauer die Option Ausführung anzeigen auswählen.