Visual Studio Code kullanarak Azure Logic Apps Kural Altyapısı projesi oluşturma

Şunlar için geçerlidir: Azure Logic Apps (Standart)

İş mantığını Azure Logic Apps'teki Standart iş akışlarınızla tümleştirmek istediğinizde, Visual Studio Code kullanarak bir Azure Logic Apps Kural Altyapısı projesi oluşturabilir ve oluşturabilirsiniz. Kurallar, iş süreçlerinin çalışma şekline ilişkin iş mantığını yönetir.

Bu kılavuzda Azure Logic Apps Kural Altyapısı projesinin nasıl oluşturulacağı gösterilmektedir:

Microsoft Rules Composer ile projeniz için iş kuralları oluşturma da dahil olmak üzere Azure Logic Apps Kural Altyapısı projenizi oluşturmaya yönelik önkoşullar ve kurulum.
Varsa, mevcut kuralları Microsoft BizTalk Server'dan dışarı aktarın.
Visual Studio Code kullanarak Azure Logic Apps Kural Altyapısı için bir Standart mantıksal uygulamalar projesi oluşturun.

Önkoşullar

Kural kümeleri, iş kuralları ve sözlükler oluşturmak için kullandığınız Microsoft Rules Composer'ı indirip yükleyin.

Kural altyapısı projenize yönelik iş oluşturmak için aşağıdaki belgelere bakın:
- Microsoft Rules Composer ile kurallar oluşturma
- Azure Logic Apps Kural Altyapısı'nı kullanarak karar yönetimi ve iş mantığı tümleştirmesi
Bu sürümde, Azure Logic Apps Kural Altyapısı projesi için geliştirme deneyimini yalnızca Visual Studio Code destekler. Visual Studio Code'u kullanma önkoşullarını karşılamak için bkz . Visual Studio Code kullanarak tek kiracılı Azure Logic Apps'te Standart mantıksal uygulama iş akışı oluşturma.
Azure Logic Apps Kural Altyapısı, Visual Studio Code'daki özel kod işlevi özelliğini kullanır. Bu özelliği kullanmanın önkoşullarını karşılamak için bkz . Azure Logic Apps'te Standart iş akışlarından .NET Framework kodu oluşturma ve çalıştırma.

Projenizi oluşturmadan önce

Başarılı bir kural altyapısı projesinden emin olmanıza yardımcı olmak için aşağıdaki genel görevleri ve en iyi yöntemleri gözden geçirin ve gerçekleştirin:

İş kurallarının iş süreçlerinize nasıl uygun olduğunu belirleyin.
uygulamanıza iş kurallarının nasıl dahil yapılacağını planlayın.
Uygulamanızdaki kurallarla temsil etmek istediğiniz iş mantığını belirleyin.

"İş mantığı" terimi birçok şeye başvurabilir. Örneğin, iş mantığı "500 dolardan büyük satın alma siparişleri için yönetici onayı gerekiyor" olabilir.
Kural öğeleriniz için veri kaynaklarını tanımlayın. İsteğe bağlı olarak, temel bağlamaları temsil eden etki alanına özgü sıfat olan sözlükleri tanımlayabilirsiniz.
Sözlük tanımlarından veya doğrudan veri bağlamalarından kullanılacak kuralları tanımlayın. Bu kurallardan, iş mantığınızı temsil eden bir kural kümesi oluşturun.

Microsoft BizTalk Server'dan kuralları dışarı aktarma

Microsoft BizTalk Server'daki mevcut kuralları yeniden kullanmak için bunları dışarı aktarabilirsiniz. Ancak, veritabanı bilgileri şu anda desteklenmiyor. Kurallarınızı dışarı aktarmadan önce, Microsoft BizTalk Rules Composer'ı kullanarak bunları diğer olgu türlerine kaldırın veya yeniden düzenleyebilirsiniz.

Microsoft BizTalk Server'dan İş Kuralları Altyapısı Dağıtım Sihirbazı'nı başlatın.
Kural Altyapısı Dağıtım Sihirbazı'na Hoş Geldiniz sayfasında İleri'yi seçin.
Dağıtım Görevi sayfasında İlkeyi/Sözcük Dağarcığını veritabanından dosyaya aktar'ı ve ardından İleri'yi seçin.
İlke Deposu sayfasındaki SQL Server Adı listesinde SQL sunucunuzu seçin. Seçili sunucudaki Yapılandırma Veritabanı listesinde BizTalkRuleEngineDb'yi ve ardından İleri'yi seçin.
Politika/Sözcük Dağarcığı Dışa Aktarma sayfasında, Politika listesinde istediğiniz politikayı seçin. Tanım dosyasını bulmak ve seçmek için Gözat'ı seçin.
Hazır olduğunuzda İleri'yi seçin.
Sunucu, veritabanı ve ilke veya sözlük bilgilerini onaylayın ve İleri'yi seçin.
İçeri veya dışarı aktarma işlemi tamamlandıktan sonra İleri'yi seçin.
İçeri veya dışarı aktarma işleminin tamamlanma durumunu gözden geçirin ve Son'u seçin.

Azure Logic Apps Kural Altyapısı projesi oluşturma

Visual Studio Code'daki Etkinlik Çubuğu'nda Azure simgesini seçin. (Klavye: Shift+Alt+A)
Açılan Azure penceresinde, Çalışma Alanı bölüm araç çubuğunda, Azure Logic Apps menüsünden Yeni mantıksal uygulama çalışma alanı oluştur'u seçin.
Klasör seç kutusunda, projeniz için oluşturduğunuz yerel klasöre göz atın ve seçin.
Yeni mantıksal uygulama çalışma alanı oluştur istemi kutusu görüntülendiğinde, çalışma alanınız için bir ad belirtin:

Bu örnek MyLogicAppRulesWorkspace ile devam eder.
Mantıksal uygulama çalışma alanınız için proje şablonu seçin istemi kutusu görüntülendiğinde, Kural altyapısı projesi ile mantıksal uygulama'yı seçin.

Aşağıdaki örnek değerleri sağlamak için sonraki istemleri izleyin:

Öğe	Örnek değer
İşlevler projesi için işlev adı	RulesFunction
İşlevler projesinin ad alanı ismi	Contoso
Mantıksal Uygulama:	LogicApp
İş akışı şablonu: - Durumlu İş Akışı - Durum Bilgisi Olmayan İş Akışı	Durumlu İş Akışı
İş akışı adı	MyRulesWorkflow

Geçerli pencerede aç'ı seçin.

Bu adımı tamamladıktan sonra Visual Studio Code, varsayılan olarak bir işlev projesi ve mantıksal uygulama kuralları altyapısı projesi içeren çalışma alanınızı oluşturur, örneğin:

Düğüm	Açıklama
*< çalışma alanı-adı>*	hem işlev projenizi hem de mantıksal uygulama iş akışı projenizi içerir.
İşlev	İşlev projenizin artefaktlarını içerir. Örneğin işlev *<adı>.cs* dosyası, kodunuzu yazabileceğiniz kod dosyasıdır.
LogicApp	Mantık uygulamanızın kurallar motoru projesinin, iş akışı dahil, öğelerini içerir.

Kural motoru kodunuzu yazın

Çalışma alanınızda, henüz genişletilmemişse İşlevler düğümünü genişletin.

< function-name>.cs dosyasını açın, bu örnekte RulesFunction.cs olarak adlandırılmıştır.

Varsayılan olarak, bu dosya aşağıdaki kod öğelerinin yanı sıra uygun yerlerde önceden sağlanan örnek değerleri içeren örnek kodu içerir:

Ad alanı adı
Sınıf adı
İşlev adı
İşlev parametreleri
Dönüş türü
Karmaşık tür

Aşağıdaki örnekte adlı RulesFunctionişlevin tam örnek kodu gösterilmektedir:

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

İşlev tanımı RulesFunction için, kullanmaya başlamak amacıyla kullanabileceğiniz varsayılan bir RunRules yöntemi içerir. Bu örnek RunRules yöntem, parametrelerin Azure Logic Apps kurallar motoruna nasıl geçirileceğini gösterir. Bu örnekte yöntem kural kümesi adını, giriş belgesi türünü, XML olgusunu ve daha fazla işleme için diğer değerleri geçirir.

İşlev-ismi<>.cs dosyası, bir Application Insights kaynağına olayları günlüğe kaydetmek için destek sağlayan ILogger arabirimini de içerir. Application Insights'a izleme bilgileri gönderebilir ve bu bilgileri iş akışlarınızdaki izleme bilgileriyle birlikte depolayabilirsiniz. < >.cs dosyası, kural kümesine FileStoreRuleExplorer erişen nesneyi de içerir. Gözlemleyebileceğiniz gibi, FileStoreRuleExplorer için oluşturucu, loggerFactory kullanarak telemetri bilgilerini Application Insights'a da gönderir.

private readonly ILogger<RulesFunction> logger;

private FileStoreRuleExplorer ruleExplorer;

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

    <...>

Azure Logic Apps Kural Altyapısı aşağıdaki adımlarda açıklandığı gibi çalışır:

Motor, kural kümesine erişmek için FileStoreRuleExplorer nesnesini kullanır. Kural kümesi dosyası, Standart mantıksal uygulamanızın Kurallar dizininde depolanır.

Bu örnek için, Microsoft Kural Oluşturucu ile oluşturulan veya Microsoft BizTalk Server kullanılarak dışa aktarılan, olarak adlandırılan kural kümesi dosyası.

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.");
}

Önemli

Kural kümeleri, olgularına referanslar tutar. Microsoft Kural Oluşturucu, düzenleme kural kümesini doğrulamak için olguların derlemelerini arar. Microsoft Rules Composer gibi SampleRuleSet.xmlkural kümelerini açmak için bunları ilgili .NET olgu derlemeleriyle yerleştirmeniz gerekir. Aksi takdirde, bir istisna alırsınız.

Motor, ruleSet nesnesini kullanarak RuleEngine nesnesinin bir örneğini oluşturur.
Kuralın olgularını RuleEngine nesnesi, Execute yöntemini kullanarak alır.

Bu örnekte, Execute yöntemi iki olgu alır: adlı typedXmlDocument bir XML olgu ve adlı currentPurchasebir .NET olgu.

Motor çalıştıktan sonra, olguların değerleri, motorun çalışmasından elde edilen değerlerle güncellenir.

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

Motor, değerleri RunRules yöntemine iade etmek için RuleExecutionResult özel sınıfını kullanır.

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

             return Task.FromResult(ruleExectionOutput);

Örnek işlev kodunu kendinizle değiştirin ve kendi senaryolarınız için varsayılan RunRules yöntemi düzenleyin.

Bu örnek, herhangi bir değişiklik yapmadan örnek kodu kullanmaya devam eder.

Kodunuzu derleyin ve oluşturun

Kodunuzu yazmayı bitirdikten sonra derleme hatası olmadığından emin olmak için derleyin. İşlev projeniz otomatik olarak derleme görevleri içerir ve ardından .NET olgu derlemeleriniz de dahil olmak üzere özel kod kitaplıklarınızdan herhangi birini iş akışlarının çalıştırılacak özel işlevleri aradığı mantıksal uygulama projenizdeki lib\custom klasörüne ekler. Bu görevler derlemeleri lib\custom\net472 klasörüne koyar.

Visual Studio Code'da, Terminal menüsünden Yeni Terminal'i seçin.
Görüntülenen çalışma dizini listesinden, yeni terminal için geçerli çalışma dizininiz olarak İşlevler'i seçin.

Visual Studio Code, komut istemi içeren bir terminal penceresi açar.
Terminal penceresinde, komut istemine dotnet restore .\RulesFunction.csproj girin.
Komut istemi yeniden gösterildikten sonra dotnet build .\RulesFunction.csproj girin.

Derlemeniz başarılı olursa, Terminal penceresi Derlemenin başarılı olduğunu bildirir.
Mantıksal uygulama projenizde aşağıdaki öğelerin mevcut olduğunu onaylayın:
- Çalışma alanınızda şu klasörleri genişletin: LogicApp>lib\custom>net472. net472 adlı alt klasörün, kodunuzun çalışması için gereken birden fazla derlemeyi içerdiğini ve <fonksiyon-adi>.dll adlı dosyayı da içerdigi̇ni̇ doğrulayın.
- Çalışma alanınızda şu klasörleri genişletin: LogicApp>lib\custom><function-name.> < function-name> adlı alt klasörün, yazdığınız işlev koduyla ilgili meta verileri içeren bir function.json dosyası içerdiğini onaylayın. İş akışı tasarımcısı, kodunuzu çağırırken gerekli girişleri ve çıkışları belirlemek için bu dosyayı kullanır.
Aşağıdaki örnek, mantıksal uygulama projesinde örnek oluşturulan derlemeleri ve diğer dosyaları gösterir:

İş akışından kurallarınızı çağırma

Kodunuzun derlendiğini ve mantıksal uygulama kuralları altyapısı projenizin kodunuzun çalışması için gerekli dosyalara sahip olduğunu onayladıktan sonra mantıksal uygulama projenize dahil edilen varsayılan iş akışını açın.

Çalışma alanınızda LogicApp altında iş akışı adını genişletin, workflow.json için kısayol menüsünü açın ve Tasarımcıyı Aç seçeneğini seçin.

Açılan iş akışı tasarımcısında, mantıksal uygulama projenize dahil edilen varsayılan iş akışı aşağıdaki tetikleyici ve eylemlerle birlikte görüntülenir:
- Http isteği alındığında adlı yerleşik İstek tetikleyicisi.
- Bu mantıksal uygulamada yerleşik olan Yerel kurallar işlevini çağır adlı eylem.
- Yalnızca İstek tetikleyicisini kullandığınızda çağıranı yanıtlamak için kullandığınız Yanıt adlı yerleşik Yanıt eylemi.
Bu mantıksal uygulamada Yerel kurallar işlevini çağır adlı eylemi seçin.

Eylemin bilgi bölmesi sağ tarafta açılır.
İşlev Adı parametre değerinin çalıştırmak istediğiniz rules işlevine ayarlandığını gözden geçirin ve onaylayın. İşlevinizin kullandığı diğer parametre değerlerini gözden geçirin veya değiştirin.

Kodunuzda ve iş akışınızda hata ayıklama

Azurite depolama öykünücüsü'ne üç kez başlamak için aşağıdaki adımları yineleyin: Aşağıdaki Azure Depolama hizmetleri için her biri bir kez:
- Azure Blob Hizmeti
- Azure Kuyruk Hizmeti
- Azure Tablo Hizmeti
1. Visual Studio Code Görünümü menüsünden Komut Paleti'ni seçin.
2. Görüntülenen istemde Azurite: Blob Hizmetini Başlat'ı bulun ve seçin.
3. Görüntülenen çalışma dizini listesinden LogicApp'i seçin.
4. Azurite için şu adımları yineleyin: Kuyruk Hizmetini Başlat ve Azurite: Tablo Hizmetini Başlat.
Ekranın alt kısmındaki Visual Studio Code görev çubuğu çalışan üç depolama hizmetini gösterdiğinde başarılısınızdır, örneğin:
Visual Studio Code Etkinlik Çubuğu'nda Çalıştır ve Hata Ayıkla'yı seçin. (Klavye: Ctrl+Shift+D)
Çalıştır ve Hata Ayıkla listesinden Mantıksal uygulamaya bağlan (LogicApp) seçeneğini belirleyin (henüz seçili değilse) ve ardından Çalıştır (yeşil ok) seçeneğini seçin.

Terminal penceresi açılır ve başlatılan hata ayıklama işlemini gösterir. Ardından Hata Ayıklama Konsolu penceresi görüntülenir ve hata ayıklama durumlarını gösterir. Visual Studio Code'un en altında görev çubuğu turuncuya döner ve .NET hata ayıklayıcısının yüklendiğini gösterir.
Kesme noktalarını ayarlamak için işlev tanımınızda (<.cs) veya iş akışı tanımınızda (>), kesme noktasını istediğiniz satır numarasını bulun ve sol taraftaki sütunu seçin, örneğin:
İstek tetikleyicisini iş akışınızda el ile çalıştırmak için iş akışının Genel Bakış sayfasını açın.
1. Mantıksal uygulama projenizde workflow.json dosyasının kısayol menüsünü açın ve Genel Bakış'ı seçin.
  
  İş akışının Genel Bakış sayfasında, iş akışını el ile başlatmak istediğinizde tetikleyiciyi çalıştır düğmesi kullanılabilir. İş Akışı Özellikleri'nin altında Geri Arama URL'si değeri, iş akışınızdaki İstek tetikleyicisi tarafından oluşturulan çağrılabilir uç noktanın URL'sidir. Diğer mantıksal uygulama iş akışları da dahil olmak üzere diğer uygulamalardan iş akışınızı tetikleme amacıyla bu URL'ye istek gönderebilirsiniz.
Genel Bakış sayfası araç çubuğunda Tetikleyiciyi çalıştır'ı seçin.

İş akışınız çalışmaya başladıktan sonra hata ayıklayıcı ilk kesme noktanızı etkinleştirir.
Çalıştır menüsünde veya hata ayıklayıcı araç çubuğunda bir hata ayıklama eylemi seçin.

İş akışı çalıştırması tamamlandıktan sonra, Genel Bakış sayfası tamamlanmış çalıştırmayı ve bu çalıştırmayla ilgili temel ayrıntıları gösterir.
İş akışı çalıştırması hakkında daha fazla bilgi gözden geçirmek için tamamlanan çalıştırmayı seçin. Alternatif olarak, Süre sütununun yanındaki listeden Çalıştırmayı göster'i seçin.
Kural Altyapısı projesiyle mantıksal uygulamalarınızı Azure Logic Apps'e dağıtmak için Dağıtıma hazırlanma adımlarını izleyin.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-03-12