Criar um projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure usando o Visual Studio Code (Visualização)

Artigo
06/13/2024

Aplica-se a: Aplicativos Lógicos do Azure (Padrão)

Importante

Esta funcionalidade está em pré-visualização e está sujeita aos Termos de Utilização Suplementares para Pré-visualizações do Microsoft Azure.

Quando quiser integrar a lógica de negócios com seus fluxos de trabalho padrão nos Aplicativos Lógicos do Azure, você pode criar e criar um projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure usando o Visual Studio Code. As regras regem a lógica de negócios para como os processos de negócios funcionam.

Este guia de instruções descreve como criar um projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure:

Pré-requisitos e configuração para criar seu projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure, incluindo a criação das regras de negócios para seu projeto com o Microsoft Rules Composer.
Exporte regras existentes do Microsoft BizTalk Server, se tiver alguma.
Crie um projeto de aplicativos lógicos padrão para o Mecanismo de Regras de Aplicativos Lógicos do Azure usando o Visual Studio Code.

Pré-requisitos

Baixe e instale o Microsoft Rules Composer, que você usa para criar conjuntos de regras, regras de negócios e vocabulários.

Para criar o negócio para seu projeto de mecanismo de regras, consulte a seguinte documentação:
- Criar regras com o Microsoft Rules Composer
- Gerenciamento de decisões e integração de lógica de negócios usando o Mecanismo de Regras de Aplicativos Lógicos do Azure
Para esta versão, apenas o Visual Studio Code dá suporte à experiência de desenvolvimento para um projeto do Azure Logic Apps Rules Engine. Para atender aos pré-requisitos para usar o Visual Studio Code, consulte Criar um fluxo de trabalho de aplicativo lógico padrão em aplicativos lógicos do Azure de locatário único usando o Visual Studio Code.
O Mecanismo de Regras de Aplicativos Lógicos do Azure usa o recurso de função de código personalizado no Visual Studio Code. Para atender aos pré-requisitos para usar esse recurso, consulte Criar e executar código do .NET Framework a partir de fluxos de trabalho padrão nos Aplicativos Lógicos do Azure.

Antes de criar o seu projeto

Para ajudá-lo a garantir um projeto de mecanismo de regras bem-sucedido, revise e execute as seguintes tarefas gerais e práticas recomendadas:

Determine como as regras de negócios se encaixam em seus processos de negócios.
Planeje como incorporar regras de negócios em seu aplicativo.
Identifique a lógica de negócios que você deseja representar com regras em seu aplicativo.

O termo "lógica de negócios" pode referir-se a muitas coisas. Por exemplo, a lógica de negócios pode ser "Ordens de compra superiores a 500 dólares requerem aprovação do gerente".
Identifique as fontes de dados para os elementos da regra. Opcionalmente, você pode definir vocabulários, que são nomenclaturas específicas do domínio que representam ligações subjacentes.
Defina as regras a serem usadas a partir de definições de vocabulário ou diretamente de ligações de dados. A partir dessas regras, crie um conjunto de regras que represente sua lógica de negócios.

Exportar regras do Microsoft BizTalk Server

Para reutilizar regras existentes do Microsoft BizTalk Server, você pode exportá-las. No entanto, os fatos de banco de dados atualmente não são suportados. Antes de exportar suas regras, remova-as ou refatore-as em outros tipos de fatos usando o Microsoft BizTalk Rules Composer.

No Microsoft BizTalk Server, inicie o Assistente de Implantação do Business Rules Engine.
Na página Bem-vindo ao Assistente de Implantação do Mecanismo de Regras, selecione Avançar.
Na página Tarefa de Implantação, selecione Exportar Política/Vocabulário para arquivo do banco de dados e selecione Avançar.
Na página Repositório de Políticas, na lista Nome do SQL Server, selecione seu servidor SQL. Na lista Banco de Dados de Configuração no servidor selecionado, selecione BizTalkRuleEngineDb e selecione Avançar.
Na página Exportar Política/Vocabulário, na lista Política, selecione a política desejada. Para localizar e escolher o arquivo de definição, selecione Procurar.
Quando estiver pronto, selecione Avançar.
Confirme o servidor, o banco de dados e as informações de política ou vocabulário e selecione Avançar.
Após a conclusão da importação ou exportação, selecione Avançar.
Revise o status de conclusão da importação ou exportação e selecione Concluir.

Criar um projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure

No Visual Studio Code, na Barra de Atividades, selecione o ícone do Azure. (Teclado: Shift+Alt+A)
Na janela do Azure que se abre, na barra de ferramentas da seção Espaço de Trabalho, no menu Aplicativos Lógicos do Azure, selecione Criar novo espaço de trabalho de aplicativo lógico.
Na caixa Selecionar pasta, procure e selecione a pasta local que você criou para seu projeto.
Quando a caixa de prompt Criar novo espaço de trabalho do aplicativo lógico for exibida, forneça um nome para seu espaço de trabalho:

Este exemplo continua com MyLogicAppRulesWorkspace.
Quando a caixa de prompt Selecione um modelo de projeto para seu espaço de trabalho de aplicativo lógico for exibida, selecione Aplicativo lógico com projeto de mecanismo de regras (visualização).

Siga os prompts subsequentes para fornecer os seguintes valores de exemplo:

Item	Valor de exemplo
Nome da função para o projeto de funções	Função Regras
Nome do namespace para o projeto de funções	Contoso.Empresa
Modelo de fluxo de trabalho: - Fluxo de trabalho com estado - Fluxo de trabalho sem estado	Fluxo de trabalho com estado
Nome do fluxo de trabalho	MyRulesWorkflow

Selecione Abrir na janela atual.

Depois de concluir esta etapa, o Visual Studio Code cria seu espaço de trabalho, que inclui um projeto de funções e um projeto de mecanismo de regras de aplicativo lógico, por padrão, por exemplo:

Nó	Description
*<nome do espaço de trabalho>*	Contém seu projeto de função e projeto de fluxo de trabalho de aplicativo lógico.
Função	Contém os artefatos para seu projeto de função. Por exemplo, o *<arquivo de nome> da função.cs* é o arquivo de código onde você pode criar seu código.
LogicApp	Contém os artefatos para seu projeto de mecanismo de regras de aplicativo lógico, incluindo um fluxo de trabalho.

Escreva o código do mecanismo de regras

No espaço de trabalho, expanda o nó Funções , se ainda não estiver expandido.

Abra o <arquivo function-name>.cs, que é chamado RulesFunction.cs neste exemplo.

Por padrão, esse arquivo contém código de exemplo que tem os seguintes elementos de código, juntamente com os valores de exemplo fornecidos anteriormente, quando apropriado:

Nome do espaço de nomes
Nome da classe
Nome da função
Parâmetros de função
Tipo de retorno
Tipo complexo

O exemplo a seguir mostra o código de exemplo completo para a função chamada 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;}
        }
    }
}

A definição de função para RulesFunction inclui um método padrão RunRules que você pode usar para começar. Este método de exemplo RunRules mostra como passar parâmetros para o Mecanismo de Regras de Aplicativos Lógicos do Azure. Neste exemplo, o método passa o nome do conjunto de regras, o tipo de documento de entrada, um fato XML e outros valores para processamento posterior.

O <arquivo .cs nome da função> também inclui a ILogger interface, que fornece suporte para registrar eventos em um recurso do Application Insights. Você pode enviar informações de rastreamento para o Application Insights e armazenar essas informações junto com as informações de rastreamento de seus fluxos de trabalho, por exemplo:

private readonly ILogger<RulesFunction> logger;

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

O Mecanismo de Regras de Aplicativos Lógicos do Azure opera conforme descrito nas seguintes etapas:

O mecanismo usa o FileStoreRuleExplorer objeto para acessar o conjunto de regras. O arquivo do conjunto de regras é armazenado no diretório Rules do seu aplicativo lógico Standard.

Neste exemplo, o arquivo de conjunto de regras é chamado SampleRuleSet.xml, que foi criado usando o Microsoft Rules Composer ou exportado usando o 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

Os conjuntos de regras contêm referências aos seus factos. O Microsoft Rules Composer procura as montagens dos fatos para validar o conjunto de regras para edição. Para abrir conjuntos de regras, como SampleRuleSet.xml no Microsoft Rules Composer, você deve colocá-los com os assemblies de fatos .NET correspondentes. Caso contrário, você terá uma exceção.
O mecanismo usa o ruleSet objeto para criar uma instância do RuleEngine objeto.

O RuleEngine objeto recebe os fatos da regra usando o Execute método.

Neste exemplo, o Execute método recebe dois fatos: um fato XML chamado typedXmlDocument e um fato .NET chamado currentPurchase.

Após o funcionamento do motor, os valores dos fatos são substituídos pelos valores que resultam da execução do 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;

O mecanismo usa a RuleExecutionResult classe personalizada para retornar os valores para o RunRules método:

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

return Task.FromResult(ruleExecutionOutput);

Substitua o código de função de exemplo pelo seu próprio e edite o método padrão RunRules para seus próprios cenários.

Este exemplo continua usando o código de exemplo sem alterações.

Compile e construa seu código

Depois de terminar de escrever o código, compile para garantir que não existam erros de compilação. Seu projeto de função inclui automaticamente tarefas de compilação, que compilam e adicionam qualquer uma de suas bibliotecas de código personalizadas, incluindo seus assemblies de fatos .NET, à pasta lib\custom em seu projeto de aplicativo lógico onde os fluxos de trabalho procuram funções personalizadas para executar. Essas tarefas colocam os assemblies na pasta lib\custom\net472 .

No Visual Studio Code, no menu Terminal , selecione Novo Terminal.
Na lista de diretórios de trabalho exibida, selecione Funções como seu diretório de trabalho atual para o novo terminal.

O Visual Studio Code abre uma janela de terminal com um prompt de comando.
Na janela Terminal, no prompt de comando, digite dotnet restore .\RulesFunction.csproj.
Depois que o prompt de comando reaparecer, digite dotnet build .\RulesFunction.csproj.

Se a compilação for bem-sucedida, a janela Terminal informará que a compilação foi bem-sucedida.
Confirme se os seguintes itens existem em seu projeto de aplicativo lógico:
- No espaço de trabalho, expanda as seguintes pastas: LogicApp>lib\custom>net472. Confirme se a subpasta chamada net472 contém os vários assemblies necessários para executar o código, incluindo um arquivo chamado< function-name>.dll.
- No espaço de trabalho, expanda as seguintes pastas: LogicApp>lib\custom<>function-name.> Confirme se a subpasta chamada <function-name> contém um arquivo function.json, que inclui os metadados sobre o código da função que você escreveu. O designer de fluxo de trabalho usa esse arquivo para determinar as entradas e saídas necessárias ao chamar seu código.
O exemplo a seguir mostra assemblies gerados de exemplo e outros arquivos no projeto de aplicativo lógico:

Ligue para suas regras a partir de um fluxo de trabalho

Depois de confirmar que o código é compilado e que o projeto do mecanismo de regras do aplicativo lógico tem os arquivos necessários para que o código seja executado, abra o fluxo de trabalho padrão incluído no projeto do aplicativo lógico.

Em seu espaço de trabalho, em LogicApp, expanda o nó de nome> do< fluxo de trabalho, abra o menu de atalho para workflow.json e selecione Abrir Designer.

No designer de fluxo de trabalho que é aberto, o fluxo de trabalho padrão, incluído com seu projeto de aplicativo lógico, aparece com o seguinte gatilho e ações:
- O gatilho de solicitação interno chamado Quando uma solicitação HTTP é recebida.
- A ação interna chamada Chamar uma função de regras locais neste aplicativo lógico.
- A ação interna de Resposta chamada Resposta, que você usa para responder ao chamador somente quando usa o gatilho Solicitação.
Selecione a ação chamada Chamar uma função de regras locais neste aplicativo lógico.

O painel de informações da ação é aberto no lado direito.
Revise e confirme se o valor do parâmetro Nome da função está definido como a função de regras que você deseja executar. Revise ou altere quaisquer outros valores de parâmetro usados pela sua função.

Depurar seu código e fluxo de trabalho

Repita as seguintes etapas para iniciar o emulador de armazenamento Azurite três vezes: uma vez cada para os seguintes serviços de Armazenamento do Azure:
- Serviço de Blob do Azure
- Serviço de Fila do Azure
- Serviço de Tabela do Azure
1. No menu Exibição de código do Visual Studio, selecione Paleta de comandos.
2. No prompt exibido, localize e selecione Azurite: Iniciar Serviço de Blob.
3. Na lista de diretórios de trabalho exibida, selecione LogicApp.
4. Repita estas etapas para Azurite: Start Queue Service e Azurite: Start Table Service.
Você é bem-sucedido quando a barra de tarefas Código do Visual Studio na parte inferior da tela mostra os três serviços de armazenamento em execução, por exemplo:
Na barra de atividades de código do Visual Studio, selecione Executar e Depurar. (Teclado: Ctrl+Shift+D)
Na lista Executar e Depurar, selecione Anexar ao aplicativo lógico (LogicApp), se ainda não estiver selecionado, e selecione Reproduzir (seta verde).

A janela Terminal é aberta e mostra o processo de depuração iniciado. A janela Debug Console é exibida e mostra os status de depuração. Na parte inferior do Visual Studio Code, a barra de tarefas fica laranja, indicando que o depurador .NET está carregado.
Na lista Executar e Depurar, selecione Anexar a Funções .NET (Funções) e, em seguida, selecione Reproduzir (seta verde).
Para definir quaisquer pontos de interrupção, na sua definição de função (<nome> da função.cs) ou definição de fluxo de trabalho (workflow.json), localize o número da linha onde pretende o ponto de interrupção e selecione a coluna do lado esquerdo, por exemplo:
Para executar manualmente o gatilho Solicitação no fluxo de trabalho, abra a página Visão geral do fluxo de trabalho.
1. No seu projeto de aplicativo lógico, abra o menu de atalho do arquivo workflow.json e selecione Visão geral.
  
  Na página Visão geral do fluxo de trabalho, o botão Executar gatilho está disponível para quando você deseja iniciar manualmente o fluxo de trabalho. Em Propriedades do Fluxo de Trabalho, o valor da URL de retorno de chamada é a URL de um ponto de extremidade chamável criado pelo gatilho Solicitação em seu fluxo de trabalho. Pode enviar pedidos para este URL para acionar o seu fluxo de trabalho a partir de outras aplicações, incluindo outros fluxos de trabalho de aplicações lógicas.
Na barra de ferramentas da página Visão geral , selecione Executar gatilho.

Depois que o fluxo de trabalho começar a ser executado, o depurador ativará seu primeiro ponto de interrupção.
No menu Executar ou na barra de ferramentas do depurador, selecione uma ação de depuração.

Após a conclusão da execução do fluxo de trabalho, a página Visão geral mostra a execução concluída e os detalhes básicos sobre essa execução.
Para revisar mais informações sobre a execução do fluxo de trabalho, selecione a execução concluída. Ou, na lista ao lado da coluna Duração , selecione Mostrar execução.