Using azure servicebus with cosmosdb

Question

Pulumi · Accepted Answer

In this program, we're going to create an Azure Service Bus Namespace with a Topic and a Queue, which are Azure's offerings for highly-reliable message queuing and publish-subscribe messaging. Alongside, we will provision an Azure Cosmos DB account, which is a globally-distributed, multi-model database service.

We will use the Azure Service Bus for message handling, whereas Cosmos DB will serve as a storage solution. Together they often form the backbone of a distributed architecture that needs to process messages and store them efficiently.

Here's what each resource is for:

- `azure-native.servicebus.Namespace`: A Service Bus namespace is a container for a set of messaging entities. You need it to begin using topics and queues.
- `azure-native.servicebus.Topic`: A topic is a publish-subscribe pattern. Publishers send messages to the topic, and subscribers receive them - without the two needing to know about each other.
- `azure-native.servicebus.Queue`: A queue is for point-to-point communication. Senders send messages, and receivers process them in the order they were added.
- `azure-native.documentdb.DatabaseAccount`: This is the Cosmos DB resource that contains your Cosmos DB instances. It allows you to configure and operate them.

Here is a Pulumi program in TypeScript to create a Service Bus Namespace, a Topic, and a Queue, along with a Cosmos DB account:

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

// Create a new resource group to contain all resources
const resourceGroup = new azure_native.resources.ResourceGroup("myResourceGroup");

// Create an Azure Service Bus Namespace
const namespace = new azure_native.servicebus.Namespace("myNamespace", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    sku: {
        name: "Standard", // Change to "Premium" for premium features
    },
});

// Create a Service Bus Topic inside the Namespace we created above
const topic = new azure_native.servicebus.Topic("myTopic", {
    resourceGroupName: resourceGroup.name,
    namespaceName: namespace.name,
});

// Create a Service Bus Queue inside the Namespace
const queue = new azure_native.servicebus.Queue("myQueue", {
    resourceGroupName: resourceGroup.name,
    namespaceName: namespace.name,
});

// Create an Azure Cosmos DB account
const cosmosDbAccount = new azure_native.documentdb.DatabaseAccount("myCosmosDbAccount", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    databaseAccountOfferType: "Standard", // Other types are available like MongoDB, Parse...
    locations: [{
        locationName: resourceGroup.location,
        failoverPriority: 0,
    }],
    // Add additional properties here, such as consistency policy and network rules
});

// Export the primary keys of the Service Bus and Cosmos DB account
export const primaryServiceBusConnectionString = namespace.name.apply(namespaceName =>
    azure_native.servicebus.listNamespaceKeys({ resourceGroupName: resourceGroup.name, namespaceName, authorizationRuleName: "RootManageSharedAccessKey" }),
);
export const primaryCosmosDbConnectionString = cosmosDbAccount.name.apply(accountName =>
    azure_native.documentdb.listDatabaseAccountConnectionStrings({ accountName, resourceGroupName: resourceGroup.name }),
);
```

This program begins by importing the required Pulumi and Azure packages. Then, it creates a new Resource Group to contain our resources. Following this, it defines a Namespace in Service Bus and creates a Topic and Queue within that namespace. The Cosmos DB account is also set up with its primary properties.

Both the Service Bus and Cosmos DB account connection strings are exported. These can be used to connect to your resources from your applications.

To run this program:

1. Save the code to a file with a `.ts` extension, for example, `index.ts`.
2. Make sure that you have the Pulumi CLI installed and configured with credentials for your Azure account.
3. Install the necessary npm packages:

```bash
npm install @pulumi/pulumi @pulumi/azure-native
```

4. Compile the TypeScript code to JavaScript:

```bash
tsc index.ts
```

5. Run `pulumi up` to create the resources. Pulumi CLI will show you the plan and prompt you to confirm the actions.

After deployment, you’ll get the connection strings as output, which you can use to start working with your Service Bus and Cosmos DB account.