◷ Reading Time: 7 minutes
Overview
Here is a breakdown of what we have to do execute FlexRule services using Azure Function Apps.
- Add the FlexRule package and your FlexRule Runtime License file to your project.
- Add a reference to FlexRule.Runtime in your project via Nuget.
- Read the incoming request with input parameters.
- Create a RunTime Engine and execute your service.
- Pass the outputs back from your Function App in your preferred format.
- Test your function with Postman.
1. Add the Package File and Runtime License File
Add the FlexRule Designer Package file to the project. e.g. AgeTitle3.frdp
Add your FlexRule RunTime License to the project.

2. Add a reference to FlexRule.Runtime
In your project, add a reference to the latest version of FlexRule.Runtime.
You can use Nuget Package Manager to add this reference.

Add the following using statements to your function class.
using FlexRule;
using FlexRule.Runner.Commands;
3. Read the Incoming Request
Start with an empty function which takes an HttpRequest.
[FunctionName("ExecuteService")]
public static async Task<List<FlexRule.Json>> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
}
Read the body of the request.
var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
Call the RunCommand method. We’ll create this method in the next step.
"AgeTitle3.frdp"
is the path to the package file we want to use.requestBody
is the value we just read above.log
is the ILogger that has been passed to the Run method.
var result = RunCommand("AgeTitle3.frdp", requestBody, log);
4. Create a RunTime Engine and Execute Your Service
Add the following 2 methods to your function class.
public static RunLogicResponse RunCommand(string packagePath, string inputString, ILogger log)
{
var inputs = (IDictionary<string, object>)Json.Parse(inputString);
var path = $"{Directory.GetCurrentDirectory()}\\{packagePath}";
var package = File.ReadAllBytes(path);
var license = File.ReadAllText("flexrule.license.lic");
var runtimeFolder = $"{Directory.GetCurrentDirectory()}\\bin";
var runCommand = new RunLogicCommand
{
Runtime = runtimeFolder,
LogicContent = package,
InputValues = inputs,
Cache = true,
};
var logger = new StringBuilder();
var output = new StringBuilder();
var h = new CommandHandler(OutputFactory.CreateString(output), OutputFactory.CreateString(logger));
try
{
h.Execute(new InitLicenseCommand(license));
var result = h.Execute(runCommand);
if(result == null)
throw new FlexRuleException(logger.ToString());
return result;
}
catch (Exception ex)
{
log.Log(LogLevel.Error, ex.Message, ex);
}
return null;
}
5. Pass the Outputs Back in the Function’s Response
By calling RunCommand()
we should receive back a RunLogicResponse
object which gets assigned to result
.
var result = RunCommand("AgeTitle3.frdp", requestBody, log);
There are two important variables you’ll need to note.
result.OutParameters
has a list of keys that the service should output.result.Result.Context.VariableContainer
is a Dictionary that holds the output keys and values.
You can use the following snippet to obtain the expected outputs from the service as a list of FlexRule.Json
objects. You can then return this list to the client calling your function or manipulate it further.
result.OutParameters.Select(outParam =>
result.Result.Context.VariableContainer[outParam] as FlexRule.Json).ToList();
Your completed Run()
method should look like this:
[FunctionName("ExecuteService")]
public static async Task<List<FlexRule.Json>> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
// Read the request body
var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
// Create a RunTime Engine and run the service
var result = RunCommand("AgeTitle3.frdp", requestBody, log);
// Format the outputs and return them as Json
return result.OutParameters.Select(outParam => result.Result.Context.VariableContainer[outParam] as FlexRule.Json).ToList();
}
6. Test your Function with Postman
The FlexRule logic in this example takes a person’s age and outputs a word to describe whether they are young or old. The Title
key in the input is currently null
and the service execution will assign an output to this value.
{
"person":{
Age: 23,
Title: null
}
}
Run your Function.


In Postman enter the address to your function.
(Postman is a tool to test Rest API endpoints – more details and download here)

In the Body tab, choose raw and enter the input for your service execution.

Click Send.

You should receive a response with your service execution completed and the outputs from the execution.

Optional: Custom DLL Files and FlexRule Extensions
If your business logic uses custom DLL files or FlexRule Extensions:
- Include the DLL files when you create a package in FlexRule Designer.
- Add the
Extension
parameter to your RunLogicCommand (from step 4).
For example, if you were using the FlexRule Azure Storage Extension, you would use the following snippet.
var runCommand = new RunLogicCommand
{
Runtime = runtimeFolder,
LogicContent = package,
InputValues = inputs,
Cache = true,
Extension = new[] { "FlexRule.Extensions.Storage.AzureStorage.dll" },
};
Optional: Custom Execution Handling
If you want more control over the execution, you can use a different RunCommand()
method which will only give you the output values without the additional functionality required to make this a production-ready solution.
In this scenario you will need to manually implement your own:
- Loading of modules from the package file.
- Loading of custom DLL files required by your service.
- Caching of the FlexRule Runtime Engine creation.
- Event handling.
- Logging of error messages.
private static object RunCommand(string packagePath, string requestBody, ILogger log)
{
try
{
// Initialise license
UserLicense.Key = File.ReadAllText("flexrule.license.lic");
// Create engine
IRuntimeEngine engine;
using (var stream = File.OpenRead(packagePath))
{
var loader = new PackageLoader(stream);
var module = loader.Modules.First();
engine = RuntimeEngine.FromRuleSet(module.Ruleset, module.Entry);
}
// Parse inputs and execute
var inputs = (IDictionary<string, object>) Json.Parse(requestBody);
var result = engine.Run(inputs);
// Get the outputs as Json
var outVariables = engine.Descriptions.ListOutVariableName();
var outputs = outVariables
.Select(outVariable => result.Context.VariableContainer[outVariable] as FlexRule.Json).ToList();
return outputs;
}
catch (Exception ex)
{
log.Log(LogLevel.Error, ex.Message, ex);
return ex.Message;
}
}