Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Se aplica a: Azure Logic Apps (estándar)
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.
Para ejecutar tus reglas desde un flujo de trabajo, utiliza una función personalizada local para conjuntos de reglas que incluyan datos .NET. Para conjuntos de reglas que usan solo datos XML, puedes usar la acción integrada Ejecutar Motor de Reglas , que actualmente está en vista previa.
En esta guía se muestra cómo crear un proyecto del motor de reglas de Azure Logic Apps:
Requisitos previos y configuración para crear tu proyecto Azure Logic Apps Rules Engine, incluyendo la creación de las reglas de negocio de tu proyecto usando el Microsoft Rules Composer.
Exporte las reglas existentes desde Microsoft BizTalk Server, si tiene alguna.
Crea un proyecto de aplicaciones de lógica estándar para el motor de reglas de Azure Logic Apps usando Visual Studio Code.
Ejecuta conjuntos de reglas desde tu flujo de trabajo usando una función personalizada local para datos .NET o la acción Ejecutar Rules Engine solo para datos XML.
Requisitos previos
Descargue e instale Microsoft Rules Composer, que se usa para crear conjuntos de reglas, reglas de negocio y vocabularios.
Para desarrollar el negocio para su proyecto de motor de reglas, consulte la siguiente documentación:
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.
Para usar datos de .NET, el motor de reglas de Azure Logic Apps utiliza la 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 sus reglas, elimínelas o refactórelas en otros tipos de hechos utilizando 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
La plantilla de proyecto crea un proyecto de funciones y un proyecto de aplicación lógica. Solo necesitas el proyecto de funciones y código personalizado cuando tu conjunto de reglas incluye datos .NET. Para conjuntos de reglas que usan solo datos XML, utiliza la acción integrada Ejecutar Rules Engine en tu flujo de trabajo.
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 de diálogo Seleccionar una plantilla de proyecto para su área de trabajo de aplicación lógica, seleccione Aplicación lógica con proyecto de motor de reglas.
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 Logic Apps: LogicApp Plantilla de flujo de trabajo:
- Flujo de trabajo con estado
- Flujo de trabajo sin estadoFlujo de trabajo persistente 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 < nombre del espacio de trabajo> Contiene tanto el proyecto de funciones como el proyecto de flujo de trabajo de la aplicación lógica. Función 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.
Escribe el código de tu motor de reglas para hechos de .NET
Si tu conjunto de reglas usa solo datos XML, salta esta sección y utiliza la acción integrada Ejecutar Rules Engine. Si tu conjunto de reglas incluye datos .NET, crea una función local personalizada como se describe en esta sección.
En su espacio 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 retorno
- 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 { 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;} } } }La definición de función para
RulesFunctionincluye un métodoRunRulespredeterminado que puede usar para empezar. Este método de ejemploRunRulesmuestra 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. El archivo <function-name>.cs también incluye el objetoFileStoreRuleExplorerque accede al conjunto de reglas. Como se puede observar, el constructor deFileStoreRuleExplorerusaloggerFactorypara enviar información de telemetría también a Application Insights.private readonly ILogger<RulesFunction> logger; private FileStoreRuleExplorer ruleExplorer; public RulesFunction(ILoggerFactory loggerFactory) { logger = loggerFactory.CreateLogger<RulesFunction>(); this.ruleExplorer = new FileStoreRuleExplorer(loggerFactory); } <...>El motor de reglas de Azure Logic Apps funciona como se describe en los pasos siguientes:
El motor usa el objeto
FileStoreRuleExplorerpara 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 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."); }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.xmlen Microsoft Rules Composer, debe colocarlos junto a los ensamblados de hechos de .NET correspondientes. De lo contrario, se produce una excepción.El motor usa el objeto
ruleSetpara crear una instancia del objetoRuleEngine.El objeto
RuleEnginerecibe los hechos de la regla mediante el métodoExecute.En este ejemplo, el método
Executerecibe dos hechos: un hecho XML denominadotypedXmlDocumenty un hecho de .NET denominadocurrentPurchase.Una vez ejecutado el motor, los valores de los hechos se sobrescriben con los valores resultantes de la ejecución del motor:
// 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;- El motor usa la clase personalizada
RuleExecutionResultpara devolver los valores al métodoRunRules:
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
RunRulespredeterminado para sus propios escenarios.Este ejemplo continúa con el código de ejemplo sin cambios.
Compila y genera tu código para .NET
Si tu conjunto de reglas usa solo datos XML y planeas usar la acción integrada Ejecutar Rules Engine , salta esta sección. Si tu conjunto de reglas incluye datos .NET, después de terminar de escribir tu código, compila para asegurarte de que no existan errores de compilación. Tu proyecto de Functions incluye automáticamente tareas de compilación que compilan y luego agregan cualquier biblioteca de código personalizada, incluidos los ensamblados de .NET Facts, a la carpeta lib\custom de tu proyecto de aplicación lógica, donde los flujos de trabajo buscan las funciones personalizadas que deben ejecutarse. 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 indicador de comandos, 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
Llamar a datos de .NET con funciones personalizadas locales
Para conjuntos de reglas que incluyan datos .NET, utiliza una función personalizada local. 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:
- Desencadenador de solicitud integrado denominado 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.
Invocar datos XML mediante la acción Ejecutar motor de reglas
Para conjuntos de reglas que usan solo datos XML, utiliza la acción integrada Ejecutar Motor de Reglas . No tienes que escribir, compilar ni llamar a una función personalizada local.
Importante
La acción Ejecutar Rules Engine está en vista previa y solo admite datos XML. Para usar .NET facts, llama a una función personalizada local.
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 flujos de trabajo, bajo el disparador o acción donde quieres ejecutar tu conjunto de reglas, añade la acción llamada Ejecutar Motor de Reglas siguiendo los pasos generales para añadir una acción a tu flujo de trabajo.
En el panel de información de acciones, desde la lista de Conjuntos de Reglas , selecciona el conjunto de reglas que quieres ejecutar. Este ejemplo selecciona Validación.
Abre la lista de parámetros avanzados .
Para cada dato XML que el conjunto de reglas seleccionado espera, la lista contiene un parámetro que comienza con el prefijo Hecho:. Este ejemplo selecciona Fact: Backend.
Selecciona cada parámetro de hecho que quieras proporcionar.
Para cada parámetro de hecho, proporciona el documento XML correspondiente.
Puedes introducir XML o seleccionar la salida XML de una operación de flujo de trabajo anterior. Este ejemplo utiliza la salida Body XML de un Compose XML anterior con acción de esquema.
Cuando se ejecuta la acción, el motor de reglas aplica el conjunto de reglas seleccionado a los hechos XML. Puedes usar la salida de la acción en operaciones de flujo de trabajo posteriores. En este ejemplo, el flujo de trabajo utiliza Parse XML con esquema para procesar el XML resultante.
Depura tu código y flujo de trabajo.
Los siguientes pasos se aplican cuando usas una función personalizada local para conjuntos de reglas que incluyen datos .NET. Para un conjunto de reglas basado únicamente en XML que usa la acción integrada Execute Rules Engine, depura el flujo de trabajo y revisa las entradas y salidas de la acción en el historial de ejecución del 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 de Tablas de Azure
Desde el menú Vista de Visual Studio Code, seleccione Paleta de comandos.
En el aviso que aparece, busque y seleccione Azurite: Iniciar Servicio de blobs.
En la lista de directorios de trabajo que aparece, seleccione LogicApp.
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 Adjuntar a la aplicación lógica (LogicApp) si aún no está seleccionada y, a continuación, seleccione Iniciar (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.
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.
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.
Para implementar las aplicaciones lógicas con el proyecto del motor de reglas en Azure Logic Apps, siga los pasos descritos en Preparación para la implementación.
