Criar um projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure usando o Visual Studio Code

Aplica-se a: Aplicativos Lógicos do Azure (Standard)

Quando quiser integrar a lógica de negócios aos fluxos de trabalho Standard nos Aplicativos Lógicos do Azure, você poderá 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 de como os processos empresariais 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.
Exportar regras existentes do Microsoft BizTalk Server, se você tiver alguma.
Criar 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

Baixar e instalar 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 o projeto do mecanismo de regras, consulte a seguinte documentação:
- Criar regras com o Microsoft Rules Composer
- Gerenciamento de decisões e integração lógica de negócios usando o Mecanismo de Regras de Aplicativos Lógicos do Azure
Para esta versão, somente o Visual Studio Code dá suporte à experiência de desenvolvimento para um projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure. Para atender aos pré-requisitos para usar o Visual Studio Code, consulte Criar um fluxo de trabalho de aplicativo lógico Standard nos 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 a funcionalidade de função de código personalizada no Visual Studio Code. Para atender aos pré-requisitos para usar essa funcionalidade, consulte Criar e executar o código do .NET Framework de fluxos de trabalho Standard nos Aplicativos Lógicos do Azure.

Antes de criar seu projeto

Para ajudá-lo a garantir um projeto bem-sucedido do mecanismo de regras, examine 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 ao seu aplicativo.
Identifique a lógica de negócios que você deseja representar com as regras em seu aplicativo.

O termo "lógica de negócios" pode se referir a muitas coisas. Por exemplo, a lógica de negócios pode ser "Pedidos de compra maiores que 500 dólares exigem aprovação do gerente."
Identifique fontes de dados para seus elementos de regra. Opcionalmente, você pode definir vocabulários, que são nomenclatura específicas do domínio que representa associações subjacentes.
Defina as regras a serem usadas de definições de vocabulário ou diretamente de associações de dados. Com base nessas regras, crie um conjunto de regras que represente sua lógica de negócios.

Exportar regras do Microsoft BizTalk Server

Para reutilizar as regras existentes do Microsoft BizTalk Server, você pode exportá-las. No entanto, atualmente, não há suporte para fatos de BD. Antes de exportar suas regras, remova 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 Mecanismo de Regras de Negócios.
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 o arquivo do banco de dados e selecione Avançar.
Na página Repositório de Políticas, na lista Nomes do SQL Server, selecione seu SQL Server. Na lista de servidores selecionados do Banco de Dados de Configuração, selecione BizTalkRuleEngineDb e selecione Avançar.
Na página Política de Exportação/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 Próximo.
Confirme as informações de servidor, banco de dados e política ou vocabulário e selecione Avançar.
Depois que a importação ou exportação for concluída, selecione Avançar.
Examine 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 Atividades, selecione o ícone do Azure. (Teclado: Shift+Alt+A)
Na janela do Azure aberta na barra de ferramentas da seção Espaço de Trabalho, no menu Aplicativos Lógicos do Azure, selecione Criar um novo espaço de trabalho de aplicativo lógico.
Na caixa Selecionar pasta, navegue e selecione a pasta local criada para seu projeto.
Quando a caixa de solicitação Criar novo espaço de trabalho do aplicativo lógico for exibida, forneça um nome para o espaço de trabalho:

Este exemplo continua com MyLogicAppRulesWorkspace.
Quando a caixa de solicitação Selecionar um modelo de projeto para o workspace do aplicativo lógico for exibida, selecione Aplicativo lógico com projeto de código personalizado.

Siga as instruções subsequentes para fornecer os seguintes valores de exemplo:

Elemento	Valor de exemplo
Nome da função para o projeto de funções	RulesFunction
Nome do namespace para o projeto de funções	Contoso
Aplicativo Lógico:	do LogicApp
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.

Após a conclusão dessa etapa, o Visual Studio Code criará seu espaço de trabalho, que inclui um projeto de funções e um projeto de aplicativo lógico, por padrão, por exemplo:

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

Escrever o código do mecanismo de regras

Em seu espaço de trabalho, expanda o nó Functions, 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 um código de exemplo que tem os seguintes elementos de código, juntamente com os valores de exemplo fornecidos anteriormente, quando apropriado:

Nome do Namespace
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
{
     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;}
         }
     }
}

A definição de função para RulesFunction inclui um método RunRules padrão que você pode usar para começar. Este método RunRules de amostra 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 adicional.

O arquivo <function-name>.cs também inclui a interface ILogger, que fornece suporte aos eventos de registro em log 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. O arquivo <function-name>.cs também inclui o objeto FileStoreRuleExplorerque acessa o conjunto de regras. Como você pode observar, o construtor para o FileStoreRuleExplorer usa o loggerFactory para enviar informações de telemetria também para o Application Insights.

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

public RulesFunction(ILoggerFactory loggerFactory)
     {
         logger = loggerFactory.CreateLogger<RulesFunction>();
         this.ruleExplorer = new FileStoreRuleExplorer(loggerFactory); 
     }

    <...>

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

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

Para este 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 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

Os conjuntos de regras têm referências aos fatos. O Microsoft Rules Composer procura os assemblies 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 do .NET correspondentes. Caso contrário, você receberá uma exceção.

O mecanismo usa o objeto ruleSet para criar uma instância do objeto RuleEngine.
O objeto RuleEngine recebe os fatos da regra usando o método Execute.

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

Depois que o mecanismo é executado, os valores dos fatos são substituídos com os valores resultantes da execução do mecanismo:

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

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

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

             return Task.FromResult(ruleExectionOutput);

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

Esse exemplo continua com o código de exemplo sem nenhuma alteração.

Compilar e criar seu código

Após terminar de escrever seu código, compile para garantir que não haja erros de compilação. Seu projeto de função inclui automaticamente tarefas de build, que compilam e adicionam qualquer uma de suas bibliotecas de código personalizadas, incluindo seus assemblies de fatos do .NET, à pasta lib\custom em seu projeto de aplicativo lógico em que os fluxos de trabalho procuram funções personalizadas para execução. 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 abrirá 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:
- Em seu 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 seu código, incluindo um arquivo chamado <function-name>.dll.
- No seu 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 do 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 exemplos de assemblies gerados e outros arquivos no projeto do aplicativo lógico:

Chamar suas regras de um fluxo de trabalho

Após a confirmação da compilação do código e de que o projeto do aplicativo lógico contém os arquivos necessários para a execução do código, abra o fluxo de trabalho padrão incluído no projeto do aplicativo lógico.

No seu espaço de trabalho, em LogicApp, expanda o nó <workflow-name>, abra o menu de atalho para workflow.json e selecione Abrir Designer.

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

O painel de informações da ação será aberto à direita.
Examine e confirme se o valor do parâmetro Nome da Função está definido para a função que você deseja executar. Examinar ou alterar quaisquer outros valores de parâmetro que sua função utiliza.

Depurar seu código e fluxo de trabalho

Repita as etapas a seguir para iniciar o emulador de armazenamento Azurite três vezes: uma vez para cada um dos seguintes serviços de Armazenamento do Microsoft Azure:
- Serviço Blob do Azure
- Serviço de Fila do Azure
- Serviço Tabela do Azure
1. No menu Exibir do Visual Studio Code, selecione Paleta de Comandos.
2. No prompt que aparece, encontre e selecione Azurite: Iniciar Serviço de Blobs.
3. Na lista de diretórios de trabalho exibida, selecione LogicApp.
4. Repita essas etapas para Azurite: Iniciar Serviço de Fila e Azurite: Iniciar Serviço de Tabela.
Você será bem-sucedido quando a barra de tarefas do Visual Studio Code na parte inferior da tela mostrar os três serviços de armazenamento em execução, por exemplo:
Na Barra de Atividades do Visual Studio Code, 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 depois Reproduzir (seta verde).

A janela Terminal será aberta e mostrará o processo de depuração iniciado. A janela Console de depuração aparecerá e mostrará os status da depuração. Na parte inferior do Visual Studio Code, a barra de tarefas ficará laranja, indicando que o depurador .NET foi carregado.
Para definir qualquer ponto de interrupção, na definição da função (<function-name>.cs) ou na definição do fluxo de trabalho (workflow.json), encontre o número da linha na qual deseja o ponto de interrupção e selecione a coluna à esquerda, por exemplo:
Para executar manualmente o gatilho Solicitar em seu fluxo de trabalho, abra a página Visão geral do fluxo de trabalho.
1. No projeto do 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ê quiser iniciar manualmente o fluxo de trabalho. Em Propriedades do Fluxo de Trabalho, o valor URL da Chamada de Retorno é a URL de um ponto de extremidade que pode ser chamado criado pelo gatilho Solicitar em seu fluxo de trabalho. Você pode enviar solicitações a essa URL para disparar seu fluxo de trabalho a partir de outros aplicativos, inclusive outros fluxos de trabalho de aplicativos lógicos.
Na barra de ferramentas da página Visão geral, selecione Executar gatilho.

Após o início da execução do fluxo de trabalho, o depurador ativa 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.
Para implantar seus aplicativos lógicos com o projeto do Mecanismo de Regras nos Aplicativos Lógicos do Azure, siga as etapas em Preparar para implantação.

Comentários

Esta página foi útil?

Last updated on 2025-05-20