Applying a SQLFilter to a Service Bus Subscription Rule

Question

Pulumi · Accepted Answer

When you want to apply a SQLFilter to a Service Bus Subscription in Azure using Pulumi, you will need to use the `azure-native.servicebus:Rule` resource. This resource allows you to create a rule for a subscription that specifies how Service Bus should filter messages.

The SQLFilter is a type of filter that evaluates the data from the messages against a SQL expression. If the expression returns true for a given message, that message will be passed into the subscription. This is particularly useful when you want to have fine-grained control over the messages that should be processed by a specific subscription.

Here is a step-by-step walkthrough of the code to apply a SQLFilter to a Service Bus Subscription Rule using Pulumi with TypeScript:

1. We start by importing the required `azure-native` modules. Specifically, we'll need `servicebus` for the Service Bus resources.
2. We create a new Service Bus Namespace, a topic within that namespace, and a subscription to that topic.
3. We then create a Service Bus Rule with a SQLFilter. The filter will have an SQL expression such as `"sys.label = 'Sales'"`, which only selects messages with a label property of 'Sales'.

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const resourceGroupName = "resourceGroup";
const namespaceName = "namespace";
const topicName = "topic";
const subscriptionName = "subscription";
const ruleName = "rule";

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup(resourceGroupName);

// Create an Azure Service Bus Namespace
const serviceBusNamespace = new azure_native.servicebus.Namespace(namespaceName, {
    resourceGroupName: resourceGroupName,
    location: resourceGroup.location,
});

// Create an Azure Service Bus Topic within the Namespace
const topic = new azure_native.servicebus.Topic(topicName, {
    resourceGroupName: resourceGroupName,
    namespaceName: namespaceName,
});

// Create a Subscription to the Topic 
const subscription = new azure_native.servicebus.Subscription(subscriptionName, {
    resourceGroupName: resourceGroupName,
    namespaceName: namespaceName,
    topicName: topic.name,
});

// Create a Rule for the Subscription to filter messages
const rule = new azure_native.servicebus.Rule(ruleName, {
    resourceGroupName: resourceGroupName,
    namespaceName: namespaceName,
    topicName: topic.name,
    subscriptionName: subscription.name,
    filterType: "SqlFilter",
    sqlFilter: {
        sqlExpression: "sys.label = 'Sales'",
        requiresPreprocessing: false
    },
});

export const ruleId = rule.id;
```

In the code above:

- `resourceGroup` - represents the Azure Resource Group where all resources will be deployed.
- `serviceBusNamespace` - the Azure Service Bus Namespace that acts as a container for all messaging components.
- `topic` - a named, partitioned message stream that subscriptions can listen to.
- `subscription` - a mechanism for receiving messages published to the topic that match particular criteria.
- `rule` - defines the SQLFilter for messages being delivered to the subscription. In this example, we're only delivering messages that have a label property equal to 'Sales'.

Finally, we export `ruleId`, which can provide us with the ID of the rule we've set up once the program is deployed. This could be useful for querying or updating the rule in the future.

You can customize the `sqlExpression` value in the `sqlFilter` property to match the conditions you need for your application.

Please note that the names for the resources above (`namespaceName`, `topicName`, `subscriptionName`, and `ruleName`) are placeholders and should be replaced with your actual Service Bus Namespace, Topic, Subscription, and Rule names. Also, the resource group name provided should be the one you're using in Azure.

This TypeScript code can be placed in a Pulumi program file, and upon running `pulumi up`, the Pulumi CLI will orchestrate the creation of these resources in your Azure subscription. Make sure you have Azure configured correctly with Pulumi, as the CLI will need appropriate permissions to create resources in your cloud environment.

For more information about the resources used here, you can visit the documentation:

- For Resource Group: [ResourceGroup](https://www.pulumi.com/docs/reference/pkg/azure-native/resources/resourcegroup/)
- For Service Bus Namespace: [Namespace](https://www.pulumi.com/docs/reference/pkg/azure-native/servicebus/namespace/)
- For Service Bus Topic: [Topic](https://www.pulumi.com/docs/reference/pkg/azure-native/servicebus/topic/)
- For Subscription: [Subscription](https://www.pulumi.com/docs/reference/pkg/azure-native/servicebus/subscription/)
- For Rule with SQLFilter: [Rule](https://www.pulumi.com/docs/reference/pkg/azure-native/servicebus/rule/)