Criar um projeto do Mecanismo de Regras de Aplicativos Lógicos do Azure usando o Visual Studio Code (versão prévia)

Artigo
01/27/2025

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

Importante

Esse recurso está em versão prévia e está sujeito aos Termos de uso suplementares para versões prévias do Microsoft Azure.

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 seu workspace do aplicativo lógico for exibida, selecione Aplicativo lógico com projeto de código personalizado (versão prévia).

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

Item	Valor de exemplo
Nome da função para o projeto de funções	RulesFunction
Nome do namespace para o projeto de funções	Contoso.Enterprise
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
*<workspace-name>*	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.
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.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 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. Envie informações de rastreamento para o Application Insights e armazene 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 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 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 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 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 classe personalizada RuleExecutionResult para retornar os valores ao método RunRules:

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

return Task.FromResult(ruleExecutionOutput);

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.
Na lista Executar e Depurar, selecione Anexar às Funções .NET (Funções) e, em seguida, Reproduzir (seta verde).
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.