Creación de un proyecto del motor de reglas de Azure Logic Apps mediante Visual Studio Code (versión preliminar)

Artículo
06/18/2024

Se aplica a: Azure Logic Apps (estándar)

Importante

Esta funcionalidad está en versión preliminar y está sujeta a las Condiciones de uso complementarias para las versiones preliminares de Microsoft Azure.

Cuando quiera integrar la lógica de negocios con los flujos de trabajo estándar en Azure Logic Apps, puede crear y compilar un proyecto del motor de reglas de Azure Logic Apps mediante Visual Studio Code. Las reglas rigen la lógica de funcionamiento de los procesos empresariales.

En esta guía paso a paso se describe cómo crear un proyecto del motor de reglas de Azure Logic Apps:

Requisitos previos y configuración para crear el proyecto del motor de reglas de Azure Logic Apps, incluida la creación de reglas de negocios para el proyecto con Microsoft Rules Composer.
Exporte las reglas existentes desde Microsoft BizTalk Server, si tiene alguna.
Cree un proyecto de aplicaciones lógicas estándar para el motor de reglas de Azure Logic Apps mediante Visual Studio Code.

Requisitos previos

Descargue e instale Microsoft Rules Composer, que se usa para crear conjuntos de reglas, reglas de negocio y vocabularios.

Para compilar la empresa para el proyecto del motor de reglas, consulte la siguiente documentación:
- Creación de reglas con Microsoft Rules Composer
- Integración de la lógica de negocios y la administración de decisiones mediante el motor de reglas de Azure Logic Apps
Para esta versión, solo Visual Studio Code admite la experiencia de desarrollo de un proyecto de motor de reglas de Azure Logic Apps. Para cumplir los requisitos previos para usar Visual Studio Code, consulte Creación de un flujo de trabajo de aplicación lógica estándar en Azure Logic Apps de un solo inquilino mediante Visual Studio Code.
El motor de reglas de Azure Logic Apps usa la funcionalidad de función de código personalizado en Visual Studio Code. Para cumplir los requisitos previos para usar esta funcionalidad, consulte Creación y ejecución de código de .NET Framework desde flujos de trabajo estándar en Azure Logic Apps.

Antes de crear el proyecto

Para ayudarle a garantizar un proyecto de motor de reglas correcto, revise y realice las siguientes tareas generales y procedimientos recomendados:

Determine cómo encajan las reglas de negocio en los procesos empresariales.
Planee cómo incorporar reglas de negocio a la aplicación.
Identifique la lógica de negocios que desea representar con reglas en su aplicación.

El término "lógica de negocios" puede hacer referencia a muchas cosas. Por ejemplo, la lógica de negocios podría ser "Los pedidos de compra superiores a 500 dólares requieren la aprobación del administrador".
Identifique los orígenes de datos para los elementos de su regla. Opcionalmente, puede definir vocabularios, que son nomenclatura específica del dominio que representa enlaces subyacentes.
Defina las reglas que se van a usar desde definiciones de vocabulario o directamente desde enlaces de datos. A partir de esas reglas, cree un conjunto de reglas que represente la lógica de negocios.

Exportación de reglas desde Microsoft BizTalk Server

Para reutilizar las reglas existentes de Microsoft BizTalk Server, puede exportarlas. Sin embargo, actualmente no se admiten hechos de base de datos. Antes de exportar las reglas, quite o refactorice en otros tipos de hechos mediante Microsoft BizTalk Rules Composer.

En Microsoft BizTalk Server, inicie el Asistente para la implementación del motor de reglas de negocios.
En la página Bienvenida al Asistente para la implementación del motor de reglas, seleccione Siguiente.
En la página Tarea de implementación, seleccione Exportar directiva o vocabulario al archivo desde la base de datos y seleccione Siguiente.
En la página Almacén de directivas, en la lista Nombre de SQL Server, seleccione el servidor SQL Server. En la lista Base de datos de configuración en el servidor seleccionado, seleccione BizTalkRuleEngineDb y, a continuación, seleccione Siguiente.
En la página Exportar directiva o vocabulario, en la lista Directiva, seleccione la directiva que desee. Para buscar y elegir el archivo de definición, seleccione Examinar.
Cuando esté listo, seleccione Siguiente.
Confirme la información de servidor, base de datos y directiva o vocabulario y seleccione Siguiente.
Una vez finalizada la importación o exportación, seleccione Siguiente.
Revise el estado de finalización de la importación o exportación y seleccione Finalizar.

Creación de un proyecto del motor de reglas de Azure Logic Apps

En la barra de actividad de Visual Studio Code, seleccione el icono de Azure. (Teclado: Mayús + Alt + A)
En la ventana de Azure que se abre, en la barra de herramientas de la sección Área de trabajo, en el menú Azure Logic Apps, seleccione Crear una nueva área de trabajo de la aplicación lógica.
En el cuadro Seleccionar carpeta, vaya a la carpeta local que creó para el proyecto y selecciónela.
Cuando aparezca el cuadro Creación de un área de trabajo de aplicación lógica, proporcione un nombre para el área de trabajo:

Este ejemplo continúa con MyLogicAppRulesWorkspace.
Cuando aparezca el cuadro Selección de una plantilla de proyecto para el área de trabajo de la aplicación lógica, seleccione Aplicación lógica con proyecto del motor de reglas (versión preliminar).

Siga las solicitudes posteriores para proporcionar los siguientes valores de ejemplo:

Elemento	Valor de ejemplo
Nombre de función para el proyecto de funciones	RulesFunction
Nombre del espacio de nombres para el proyecto de funciones	Contoso.Enterprise
Plantilla de flujo de trabajo: - Flujo de trabajo con estado - Flujo de trabajo sin estado	Flujo de trabajo con estado
Nombre del flujo de trabajo	MyRulesWorkflow

Seleccione Abrir en la ventana actual.

Después de finalizar este paso, Visual Studio Code crea el área de trabajo, que incluye un proyecto de funciones y un proyecto de motor de reglas de aplicación lógica, de manera predeterminada, por ejemplo:

Nodo	Descripción
*<workspace-name>*	Contiene el proyecto de función y el proyecto de flujo de trabajo de la aplicación lógica.
Function	Contiene los artefactos del proyecto de función. Por ejemplo, el archivo *<function-name>.cs* es el archivo de código donde puede crear el código.
LogicApp	Contiene los artefactos para el proyecto del motor de reglas de aplicación lógica, incluido un flujo de trabajo.

Escritura del código del motor de reglas

En el área de trabajo, expanda el nodo Funciones, si aún no está expandido.

Abra el archivo <function-name>.cs, que se denomina RulesFunction.cs en este ejemplo.

De manera predeterminada, este archivo contiene código de ejemplo que tiene los siguientes elementos de código junto con los valores de ejemplo proporcionados anteriormente cuando corresponda:

Nombre del espacio de nombres
Nombre de la clase
Nombre de función
Parámetros de función
Tipo de valor devuelto
Tipo complejo

En el ejemplo siguiente se muestra el código de ejemplo completo de la función denominada 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;}
        }
    }
}

La definición de función para RulesFunction incluye un método RunRules predeterminado que puede usar para empezar. Este método de ejemplo RunRules muestra cómo pasar parámetros al motor de reglas de Azure Logic Apps. En este ejemplo, el método pasa el nombre del conjunto de reglas, el tipo de documento de entrada, un hecho XML y otros valores para su posterior procesamiento.

El archivo <function-name>.cs también incluye la interfaz ILogger, que proporciona compatibilidad con el registro de eventos en un recurso de Application Insights. Puede enviar información de seguimiento a Application Insights y almacenar esa información junto con la información de seguimiento de los flujos de trabajo, por ejemplo:

private readonly ILogger<RulesFunction> logger;

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

El motor de reglas de Azure Logic Apps funciona como se describe en los pasos siguientes:

El motor usa el objeto FileStoreRuleExplorer para acceder al conjunto de reglas. El archivo del conjunto de reglas se almacena en el directorio Reglas de la aplicación lógica estándar.

En este ejemplo, el archivo del conjunto de reglas se denomina SampleRuleSet.xml, que se creó mediante Microsoft Rules Composer o exportó mediante 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.");
}
```
Importante

Los conjuntos de reglas contienen referencias a sus hechos. Microsoft Rules Composer busca los ensamblados de hechos para validar el conjunto de reglas para su edición. Para abrir conjuntos de reglas como SampleRuleSet.xml en Microsoft Rules Composer, debe colocarlos con los ensamblados de hechos de .NET correspondientes. De lo contrario, se produce una excepción.
El motor usa el objeto ruleSet para crear una instancia del objeto RuleEngine.

El objeto RuleEngine recibe los hechos de la regla mediante el método Execute.

En este ejemplo, el método Execute recibe dos hechos: un hecho XML denominado typedXmlDocument y un hecho de .NET denominado currentPurchase.

Una vez ejecutado el motor, los valores de los hechos se sobrescriben con los valores resultantes de la ejecución del motor:

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

El motor usa la clase personalizada RuleExecutionResult para devolver los valores al método RunRules:

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

return Task.FromResult(ruleExectionOutput);

Reemplace el código de función de ejemplo por el suyo propio y edite el método RunRules predeterminado para sus propios escenarios.

Este ejemplo continúa con el código de ejemplo sin cambios.

Compilar y generar el código

Después de terminar de escribir el código, compile para asegurarse de que no existen errores de compilación. El proyecto de función incluye automáticamente tareas de compilación, que se compilan y, a continuación, agregan cualquiera de las bibliotecas de código personalizadas, incluidos los ensamblados de hechos de .NET, a la carpeta lib\custom del proyecto de aplicación lógica donde los flujos de trabajo buscan funciones personalizadas que ejecutar. Estas tareas colocan los ensamblados en la carpeta lib\custom\net472.

En Visual Studio Code, desde el menú Terminal, seleccione Nuevo terminal.
En la lista de directorios de trabajo que aparece, seleccione Funciones como directorio de trabajo actual para el nuevo terminal.

Visual Studio Code abre una ventana de terminal con un símbolo del sistema.
En la ventana Terminal, en el símbolo del sistema, escriba dotnet restore .\RulesFunction.csproj.
Una vez que vuelva a aparecer el símbolo del sistema, escriba dotnet build .\RulesFunction.csproj.

Si la compilación se realiza correctamente, la ventana Terminal informa que La compilación se realizó correctamente.
Confirme que existen los siguientes elementos en el proyecto de aplicación lógica:
- En el área de trabajo, expanda las carpetas siguientes: LogicApp>lib\custom>net472. Confirme que la subcarpeta denominada net472 contiene los varios ensamblados necesarios para ejecutar el código, incluido un archivo denominado <nombre-de-la-función>.dll.
- En el área de trabajo, expanda las carpetas siguientes: LogicApp>lib\custom><function-name>. Confirme que la subcarpeta denominada <nombre-de-la-función> contiene un archivo función.json, que incluye los metadatos sobre el código de función que escribió. El diseñador de flujo de trabajo usa este archivo para determinar las entradas y salidas necesarias al llamar al código.
En el ejemplo siguiente se muestran ensamblados generados de ejemplo y otros archivos en el proyecto de aplicación lógica:

Llamada a las reglas desde un flujo de trabajo

Después de confirmar que el código se compila y que el proyecto del motor de reglas de la aplicación lógica tiene los archivos necesarios para que se ejecute el código, abra el flujo de trabajo predeterminado que se incluye con el proyecto de aplicación lógica.

En el área de trabajo, en LogicApp, expanda el nodo <workflow-name>, abra el menú contextual de workflow.json y seleccione Abrir Diseñador.

En el diseñador de flujo de trabajo que se abre, el flujo de trabajo predeterminado, incluido con el proyecto de aplicación lógica, aparece con el siguiente desencadenador y acciones:
- El desencadenar integrado Solicitud llamado Cuando se recibe una solicitud HTTP.
- La acción integrada llamada Llamar a una función de reglas local en esta aplicación lógica.
- La acción integrada Respuesta denominada Respuesta, que se usa para responder al autor de la llamada solo cuando se usa el desencadenador Solicitud.
Seleccione la acción llamada Llamar a una función de reglas local en esta aplicación lógica.

El panel de información de la acción se abre en el lado derecho.
Revise y confirme que el valor del parámetro Function Name está establecido en la función de reglas que desea ejecutar. Revise o cambie cualquier otro valor de parámetro que use la función.

Depuración del código y el flujo de trabajo

Repita los pasos siguientes para iniciar el emulador de almacenamiento de Azurite tres veces: una vez cada uno para los siguientes servicios de Azure Storage:
- Servicio Blob de Azure
- Azure Queue Service
- Servicio Tabla de Azure
1. Desde el menú Vista de Visual Studio Code, seleccione Paleta de comandos.
2. En el símbolo del sistema que aparece, busque y seleccione Azurite: Iniciar Blob Service.
3. En la lista de directorios de trabajo que aparece, seleccione LogicApp.
4. Repita estos pasos para Azurite: Iniciar Queue Service y Azurite: Iniciar Table Service.
La operación es correcta si la barra de tareas de Visual Studio Code de la parte inferior de la pantalla muestra los tres servicios de almacenamiento en ejecución, por ejemplo:
En la barra de actividad de Visual Studio Code, seleccione Ejecutar y depurar. (Teclado: Ctrl + Mayús + D)
En la lista Ejecutar y depurar, seleccione Asociar a la aplicación lógica (LogicApp) si aún no está seleccionada y, a continuación, seleccione Reproducir (flecha verde).

Se abre la ventana Terminal y se muestra el proceso de depuración iniciado. A continuación, aparece la ventana Consola de depuración y muestra los estados de depuración. En la parte inferior de Visual Studio Code, la barra de tareas se vuelve naranja, lo que indica que el depurador de .NET está cargado.
En la lista Ejecutar y depurar, seleccione Asociar a funciones de .NET (Funciones) y, a continuación, seleccione Reproducir (flecha verde).
Para establecer los puntos de interrupción, en la definición de la función (<function-name>.cs) o la definición del flujo de trabajo (workflow.json), busque el número de línea donde desee establecer el punto de interrupción y seleccione la columna en el lado izquierdo, por ejemplo:
Para ejecutar manualmente el desencadenador Solicitud en el flujo de trabajo, abra la página Información general del flujo de trabajo.
1. En el proyecto de aplicación lógica, abra el menú contextual del archivo workflow.json y seleccione Información general.
  
  En la página Información general del flujo de trabajo, el botón Ejecutar desencadenador está disponible para cuando desee iniciar manualmente el flujo de trabajo. En Propiedades del flujo de trabajo, el valor de Dirección URL de devolución de llamada es la dirección URL de un punto de conexión al que se puede llamar creado por el desencadenador Solicitud en el flujo de trabajo. Puede enviar solicitudes a esta dirección URL para desencadenar el flujo de trabajo desde otras aplicaciones, incluidos otros flujos de trabajo de aplicaciones lógicas.
En la barra de herramientas de la página Información general, seleccione Ejecutar desencadenador.

Una vez que el flujo de trabajo comienza a ejecutarse, el depurador activa el primer punto de interrupción.
En el menú Ejecutar o en la barra de herramientas del depurador, seleccione una acción de depuración.

Una vez completada la ejecución del flujo de trabajo, la página Información general muestra la ejecución finalizada y los detalles básicos sobre esa ejecución.
Para revisar más información sobre la ejecución del flujo de trabajo, seleccione la ejecución finalizada. O bien, en la lista situada junto a la columna Duración, seleccione Mostrar ejecución.