Membuat proyek Mesin Aturan Azure Logic Apps menggunakan Visual Studio Code

Berlaku pada: Azure Logic Apps (Standar)

Saat ingin mengintegrasikan logika bisnis dengan alur kerja Standar di Azure Logic Apps, Anda dapat membuat dan membangun proyek Mesin Aturan Azure Logic Apps menggunakan Visual Studio Code. Aturan mengatur logika bisnis tentang cara kerja proses bisnis.

Panduan ini memperlihatkan cara membuat proyek Mesin Aturan Azure Logic Apps:

Prasyarat dan penyiapan untuk membuat proyek Mesin Aturan Azure Logic Apps Anda, termasuk membuat aturan bisnis untuk proyek Anda dengan Microsoft Rules Composer.
Ekspor aturan yang ada dari Microsoft BizTalk Server, jika Anda memilikinya.
Buat proyek aplikasi logika Standar untuk Mesin Aturan Azure Logic Apps menggunakan Visual Studio Code.

Prasyarat

Unduh dan instal Microsoft Rules Composer, yang Anda gunakan untuk membuat aturan, aturan bisnis, dan kosakata.

Untuk membangun bisnis untuk proyek mesin aturan Anda, lihat dokumentasi berikut:
- Membuat aturan dengan Microsoft Rules Composer
- Manajemen keputusan dan integrasi logika bisnis menggunakan Mesin Aturan Azure Logic Apps
Untuk rilis ini, hanya Visual Studio Code yang mendukung pengalaman pengembangan untuk proyek Mesin Aturan Azure Logic Apps. Untuk memenuhi prasyarat untuk menggunakan Visual Studio Code, lihat Membuat alur kerja aplikasi logika Standar di Azure Logic Apps penyewa tunggal menggunakan Visual Studio Code.
Mesin Aturan Azure Logic Apps menggunakan kemampuan fungsi kode kustom di Visual Studio Code. Untuk memenuhi prasyarat untuk menggunakan kemampuan ini, lihat Membuat dan menjalankan kode .NET Framework dari alur kerja Standar di Azure Logic Apps.

Sebelum membuat proyek

Untuk membantu Anda memastikan proyek mesin aturan yang sukses, tinjau dan lakukan tugas umum dan praktik terbaik berikut:

Tentukan bagaimana aturan bisnis sesuai dengan proses bisnis Anda.
Rencanakan cara menggabungkan aturan bisnis ke dalam aplikasi Anda.
Identifikasi logika bisnis yang ingin Anda wakili dengan aturan dalam aplikasi Anda.

Istilah "logika bisnis" dapat merujuk ke banyak hal. Misalnya, logika bisnis mungkin "Pesanan pembelian yang lebih besar dari 500 dolar memerlukan persetujuan manajer."
Identifikasi sumber data untuk elemen aturan Anda. Anda dapat secara opsional menentukan kosakata, yang merupakan nomenklatur khusus domain yang mewakili pengikatan yang mendasarinya.
Tentukan aturan yang akan digunakan dari definisi kosakata atau langsung dari pengikatan data. Dari aturan tersebut, buat set aturan yang mewakili logika bisnis Anda.

Mengekspor aturan dari Microsoft BizTalk Server

Untuk menggunakan kembali aturan yang ada dari Microsoft BizTalk Server, Anda dapat mengekspornya. Namun, fakta DB saat ini tidak didukung. Sebelum Anda mengekspor aturan, hapus atau refaktor aturan ke dalam jenis fakta lain menggunakan Microsoft BizTalk Rules Composer.

Dari Microsoft BizTalk Server, mulai Panduan Penyebaran Mesin Aturan Bisnis.
Pada layar Selamat Datang di Wizard Penyebaran Mesin Aturan, pilih Berikutnya.
Pada halaman Tugas Penyebaran, pilih Ekspor Kebijakan/Kosakata untuk file dari database, dan pilih Berikutnya.
Pada halaman Policy Store, di daftar Nama SQL Server, pilih server SQL Anda. Di daftar Database Konfigurasi pada server yang dipilih, pilih BizTalkRuleEngineDb, lalu pilih Berikutnya.
Pada halaman Kebijakan Ekspor/Kosakata , dari daftar Kebijakan , pilih kebijakan yang Anda inginkan. Untuk menemukan dan memilih file definisi, pilih Telusuri.
Jika Anda sudah siap, pilih Berikutnya.
Konfirmasikan informasi server, database, dan kebijakan atau kosakata, dan pilih Berikutnya.
Setelah impor atau ekspor selesai, pilih Berikutnya.
Tinjau status penyelesaian untuk impor atau ekspor, dan pilih Selesai.

Membuat proyek Mesin Aturan Azure Logic Apps

Di Visual Studio Code, pada Bilah Aktivitas, pilih ikon Azure. (Keyboard: Shift+Alt+A)
Di jendela Azure yang terbuka, pada toolbar bagian Ruang Kerja, dari menu Azure Logic Apps , pilih Buat ruang kerja aplikasi logika baru.
Dalam kotak Pilih folder , telusuri dan pilih folder lokal yang Anda buat untuk proyek Anda.
Saat kotak perintah Buat ruang kerja aplikasi logika baru muncul, berikan nama untuk ruang kerja Anda:

Contoh ini berlanjut dengan MyLogicAppRulesWorkspace.
Saat kotak perintah Pilih templat proyek untuk ruang kerja aplikasi logika Anda muncul, pilih Aplikasi logika dengan proyek mesin aturan.

Ikuti perintah berikutnya untuk memberikan contoh nilai berikut:

Barang	Contoh nilai
Nama fungsi untuk proyek fungsional	RulesFunction
Nama namespace untuk proyek fungsi	Contoso
Aplikasi Logika:	LogicApp
Templat alur kerja: - Alur Kerja Stateful - Alur Kerja Tanpa Status	Stateful Workflow
Nama alur kerja	MyRulesWorkflow

Pilih Buka di jendela saat ini.

Setelah Anda menyelesaikan langkah ini, Visual Studio Code membuat ruang kerja Anda, yang mencakup proyek fungsi dan proyek mesin aturan aplikasi logika, secara default, misalnya:

Simpul	Deskripsi
*< nama ruang kerja>*	Berisi proyek fungsi Anda dan proyek alur kerja aplikasi logika.
Fungsi	Berisi artefak untuk proyek fungsi Anda. Misalnya, *<file function-name>.cs* adalah file kode tempat Anda dapat menulis kode Anda.
LogicApp	Mengandung komponen untuk proyek pengembangan mesin aturan logika aplikasi Anda, termasuk alur kerja.

Tulis kode mesin aturan Anda

Di ruang kerja Anda, perluas simpul Functions , jika belum diperluas.

Buka file <nama-fungsi>.cs, yang diberi nama RulesFunction.cs dalam contoh ini.

Secara default, file ini berisi kode sampel yang memiliki elemen kode berikut bersama dengan nilai contoh yang disediakan sebelumnya jika sesuai:

Nama namespace
Nama Kelas
Nama fungsi
Parameter fungsi
Tipe keluaran
Jenis kompleks

Contoh berikut menunjukkan kode sampel lengkap untuk fungsi bernama 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;}
         }
     }
}

Definisi fungsi untuk RulesFunction menyertakan metode default RunRules yang dapat Anda gunakan untuk memulai. Metode sampel RunRules ini menunjukkan cara meneruskan parameter ke Mesin Aturan Azure Logic Apps. Dalam contoh ini, metode meneruskan nama ruleset, jenis dokumen input, fakta XML, dan nilai lainnya untuk pemrosesan lebih lanjut.

File <nama> fungsi.cs juga menyertakan ILogger antarmuka, yang menyediakan dukungan untuk mencatat peristiwa ke resource Application Insights. Anda dapat mengirim informasi pelacakan ke Application Insights dan menyimpan informasi tersebut bersama informasi jejak dari alur kerja Anda. File <nama> fungsi.cs juga menyertakan FileStoreRuleExplorer objek yang mengakses set aturan. Seperti yang dapat Anda amati, konstruktor untuk FileStoreRuleExplorer menggunakan loggerFactory untuk mengirim informasi telemetri juga ke Application Insights:

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

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

    <...>

Mesin Aturan Azure Logic Apps beroperasi seperti yang dijelaskan dalam langkah-langkah berikut:

Mesin menggunakan FileStoreRuleExplorer objek untuk mengakses set aturan. File ruleset disimpan di direktori Aturan untuk aplikasi logika Standar Anda.

Untuk contoh ini, file ruleset disebut SampleRuleSet.xml, yang dibuat menggunakan Microsoft Rules Composer atau diekspor menggunakan 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.");
}

Penting

Set aturan memegang referensi terhadap fakta mereka. Microsoft Rules Composer mencari rakitan fakta untuk memvalidasi set aturan untuk pengeditan. Untuk membuka kumpulan aturan seperti SampleRuleSet.xml di Microsoft Rules Composer, Anda harus menempatkannya dengan rakitan fakta .NET yang sesuai. Jika tidak, Anda mendapatkan pengecualian.

Mesin menggunakan objek ruleSet untuk membuat instans dari objek RuleEngine.
Objek RuleEngine menerima fakta aturan menggunakan Execute metode .

Dalam contoh ini, Execute metode menerima dua fakta: fakta XML bernama typedXmlDocument dan fakta .NET bernama currentPurchase.

Setelah mesin dijalankan, nilai-nilai fakta ditimpa dengan nilai-nilai yang dihasilkan dari eksekusi mesin.

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

Mesin menggunakan RuleExecutionResult kelas kustom untuk mengembalikan nilai ke RunRules metode :

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

             return Task.FromResult(ruleExectionOutput);

Ganti kode fungsi sampel dengan kode Anda sendiri, dan edit metode default RunRules untuk skenario Anda sendiri.

Contoh ini terus menggunakan kode sampel tanpa perubahan apa pun.

Mengkompilasi dan membangun kode Anda

Setelah Anda selesai menulis kode, kompilasi untuk memastikan bahwa tidak ada kesalahan build. Proyek fungsi Anda secara otomatis menyertakan tugas build, yang mengkompilasi lalu menambahkan pustaka kode kustom Anda, termasuk rakitan .NET Anda, ke folder lib\custom di proyek aplikasi logika tempat alur kerja mencari fungsi kustom untuk dijalankan. Tugas-tugas ini menempatkan assembly di lib\custom\net472 folder.

Di Visual Studio Code, dari menu Terminal , pilih Terminal Baru.
Dari daftar direktori kerja yang muncul, pilih Fungsi sebagai direktori kerja Anda saat ini untuk terminal baru.

Visual Studio Code membuka jendela terminal dengan prompt perintah.
Di jendela Terminal , pada prompt perintah, masukkan dotnet restore .\RulesFunction.csproj.
Setelah perintah muncul kembali, masukkan dotnet build .\RulesFunction.csproj.

Jika build Anda berhasil, jendela Terminal melaporkan bahwa Build berhasil.
Konfirmasikan bahwa item berikut ada di proyek aplikasi logika Anda:
- Di ruang kerja Anda, perluas folder berikut: LogicApp>lib\custom>net472. Konfirmasikan bahwa subfolder bernama net472 berisi beberapa rakitan yang diperlukan untuk menjalankan kode Anda, termasuk file bernama< function-name>.dll.
- Di ruang kerja Anda, perluas folder berikut: LogicApp>lib\custom><function-name.> Konfirmasikan bahwa subfolder bernama <function-name> berisi file function.json, yang menyertakan metadata tentang kode fungsi yang Anda tulis. Perancang alur kerja menggunakan file ini untuk menentukan input dan output yang diperlukan saat memanggil kode Anda.
Contoh berikut menunjukkan sampel rakitan yang dihasilkan dan file lain dalam proyek aplikasi logika:

Panggil aturan Anda dari alur kerja

Setelah mengonfirmasi bahwa kode Anda dikompilasi dan bahwa proyek mesin aturan aplikasi logika Anda memiliki file yang diperlukan agar kode Anda berjalan, buka alur kerja default yang disertakan dengan proyek aplikasi logika Anda.

Di ruang kerja Anda, di bawah LogicApp, perluas node <workflow-name>, buka menu pintasan untuk workflow.json, dan pilih Buka Perancang.

Pada perancang alur kerja yang terbuka, alur kerja default, disertakan dengan proyek aplikasi logika Anda, muncul dengan pemicu dan tindakan berikut:
- Pemicu Permintaan bawaan bernama Saat permintaan HTTP diterima.
- Tindakan bawaan bernama Panggil fungsi aturan lokal di aplikasi logika ini.
- Tindakan Respons bawaan bernama Respons, yang Anda gunakan untuk membalas penelepon hanya saat Anda menggunakan pemicu Permintaan.
Pilih tindakan bernama Panggil fungsi aturan lokal di aplikasi logika ini.

Panel informasi tindakan terbuka di sisi kanan.
Tinjau dan konfirmasikan bahwa parameter Nama Fungsi diatur pada fungsi aturan yang ingin Anda jalankan. Tinjau atau ubah nilai parameter lain yang digunakan fungsi Anda.

Debug kode dan alur kerja Anda

Ulangi langkah-langkah berikut untuk memulai emulator penyimpanan Azurite tiga kali: masing-masing satu kali untuk layanan Azure Storage berikut:
- Azure Blob Service
- Azure Queue Service
- Layanan Tabel Azure
1. Dari menu Tampilan Visual Studio Code, pilih Palet Perintah.
2. Pada perintah yang muncul, temukan dan pilih Azurite: Mulai Blob Service.
3. Dari daftar direktori kerja yang muncul, pilih LogicApp.
4. Ulangi langkah-langkah ini untuk Azurite: Mulai Layanan Antrean dan Azurite: Mulai Layanan Tabel.
Anda berhasil saat taskbar Visual Studio Code di bagian bawah layar menampilkan tiga layanan penyimpanan yang berjalan, misalnya:
Pada Bilah Aktivitas Visual Studio Code, pilih Jalankan dan Debug. (Keyboard: Ctrl+Shift+D)
Dari daftar Jalankan dan Debug, pilih Lampirkan ke aplikasi logika (LogicApp), jika belum dipilih, lalu pilih Putar (panah hijau).

Jendela Terminal terbuka dan memperlihatkan proses debugging yang dimulai. Jendela Konsol Debug kemudian muncul dan menampilkan status debug. Di bagian bawah Visual Studio Code, bilah tugas berubah menjadi oranye, menunjukkan bahwa debugger .NET dimuat.
Untuk mengatur titik henti apa pun, dalam definisi fungsi Anda (<nama> fungsi.cs) atau definisi alur kerja (workflow.json), temukan nomor baris tempat Anda menginginkan titik henti, dan pilih kolom di sisi kiri, misalnya:
Untuk menjalankan pemicu Permintaan secara manual di alur kerja Anda, buka halaman Gambaran Umum alur kerja.
1. Dari proyek aplikasi logika Anda, buka menu pintasan file workflow.json , dan pilih Gambaran Umum.
  
  Pada halaman Gambaran Umum alur kerja, tombol Jalankan pemicu tersedia saat Anda ingin memulai alur kerja secara manual. Di bawah Properti Alur Kerja, URL Panggilan Balik adalah URL untuk titik akhir yang dapat dipanggil yang dibuat oleh pemicu Request di dalam alur kerja Anda. Anda dapat mengirim permintaan ke URL ini untuk memicu alur kerja Anda dari aplikasi lain, termasuk alur kerja aplikasi logika lainnya.
Pada toolbar halaman Gambaran Umum , pilih Jalankan pemicu.

Setelah alur kerja Anda mulai berjalan, debugger mengaktifkan titik henti pertama Anda.
Pada menu Jalankan atau toolbar debugger, pilih tindakan debug.

Setelah eksekusi alur kerja selesai, halaman Gambaran Umum memperlihatkan eksekusi yang sudah selesai dan detail dasar tentang eksekusi tersebut.
Untuk memeriksa informasi lebih lanjut tentang proses alur kerja, pilih proses yang sudah selesai. Atau, dari daftar di samping kolom Durasi, pilih Tampilkan jalankan.
Untuk menyebarkan aplikasi logika Anda dengan proyek Mesin Aturan ke Azure Logic Apps, ikuti langkah-langkah di Mempersiapkan penyebaran.

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-03-10