Building Scalable Serverless Microservices with Azure Functions with Cosmos DB

A Step-by-Step Adventure helps to create scalable application

Welcome to the future of microservices! In this post, we’re going to take a deep dive into developing serverless microservices using Azure Functions. With serverless architecture, you can build and scale your applications seamlessly without worrying about managing infrastructure.

Let’s get started with a fun, engaging, and step-by-step guide to help you master serverless microservices!

Why Go Serverless?

Before diving into the “how,” let’s talk about the “why.” Serverless computing allows you to focus on writing code without dealing with server management. With Azure Functions, you can:

• Scale on-demand: Functions automatically scale based on the load.
• Cost efficiency: Pay only for the resources you consume.
• Simplified development: You focus on code, Azure handles the infrastructure.

With that in mind, let’s break down the process of building serverless microservices on Azure!

📌Explore more at: https://dotnet-fullstack-dev.blogspot.com/
🌟 Clapping would be appreciated! 🚀

Step 1: Setting Up Your Azure Environment

First things first, you need an Azure subscription. If you don’t have one, no worries! Azure offers a free tier with plenty of resources to get started.

1. Login to Azure Portal and navigate to the “Create a Resource” page.
2. Search for Azure Functions and click Create.
3. Choose the appropriate subscription, and either create a new resource group or select an existing one.
4. Define your Function App Name, and choose Code for the runtime stack (we’ll be using .NET Core here).
5. Select your desired region and hit Review + Create.

With your environment set up, you’re ready to dive into the development!

Step 2: Create a New Function App

Now that the environment is ready, let’s create our first Function App.

1. In your Azure portal, navigate to your Function App and hit “Functions” under the Functions section.
2. Click “New Function” to get started.
3. Choose the template “HTTP trigger” — this will act as the entry point for your microservice.
4. Define a name for your function and select the Authorization level (for now, keep it at “Anonymous” to focus on the logic).

Once created, your function is live! You can now see the Function URL which will be your microservice’s entry point.

Step 3: Write Your First Azure Function (The Service Layer)

Now let’s get into the code. We’ll implement a simple serverless microservice that performs operations for an Item API.

using System.IO;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

public static class ItemService
{
    [FunctionName("GetItemById")]
    public static async Task<IActionResult> GetItemById(
        [HttpTrigger(AuthorizationLevel.Function, "get", Route = "items/{id}")] HttpRequest req, 
        ILogger log, 
        string id)
    {
        log.LogInformation($"Processing request for item with ID: {id}");

        var item = new { Id = id, Name = "Sample Item", Price = 99.99 };

        return new OkObjectResult(item);
    }
}

In this function, we’re setting up a simple HTTP-triggered function to retrieve an item by its ID. You can test this function by hitting the URL endpoint with the item ID in your browser or Postman.

Step 4: Connect to a Database (Cosmos DB)

Serverless microservices need data, right? Let’s connect this to Azure Cosmos DB for storing and retrieving item data. First, we’ll need to set up Cosmos DB in the Azure portal:

1. Go to “Create a resource”, search for Cosmos DB, and create it.
2. Choose the SQL API for this example (Cosmos DB supports multiple APIs).
3. Once Cosmos DB is set up, create a Database and a Collection (let’s name them “ItemsDB” and “ItemsCollection”).

Now, let’s modify our Azure Function to retrieve data from Cosmos DB:

using Microsoft.Azure.Cosmos;
public class CosmosDbService
{
    private CosmosClient _cosmosClient;
    private Container _container;

    public CosmosDbService(string databaseId, string containerId, string connectionString)
    {
        _cosmosClient = new CosmosClient(connectionString);
        _container = _cosmosClient.GetContainer(databaseId, containerId);
    }

    public async Task<Item> GetItemByIdAsync(string id)
    {
        var response = await _container.ReadItemAsync<Item>(id, new PartitionKey(id));
        return response.Resource;
    }
}

Now integrate the Cosmos DB service with your Azure Function:

[FunctionName("GetItemById")]
public static async Task<IActionResult> GetItemById(
    [HttpTrigger(AuthorizationLevel.Function, "get", Route = "items/{id}")] HttpRequest req, 
    ILogger log, 
    string id)
{
    log.LogInformation($"Fetching item from Cosmos DB for ID: {id}");
    
    var cosmosService = new CosmosDbService("ItemsDB", "ItemsCollection", Environment.GetEnvironmentVariable("CosmosDbConnectionString"));
    var item = await cosmosService.GetItemByIdAsync(id);

    if (item == null) return new NotFoundResult();
    
    return new OkObjectResult(item);
}

Now you have a function that connects to a Cosmos DB database and returns an item by its ID.

Step 5: Scale It Up!

One of the beauties of using Azure Functions is automatic scaling. As your traffic increases, Azure Functions will scale to meet the demand. You don’t need to manually configure servers or worry about hitting limits — it just works.

You can configure scaling options through Azure Portal, such as setting limits on function instances or configuring auto-scale rules based on CPU or memory usage.

Step 6: Monitoring with Azure Application Insights

You can’t improve what you can’t measure. Luckily, Azure Functions easily integrates with Application Insights for real-time monitoring.

Enable Application Insights in your function app settings, and then use the Logs and Metrics tabs to track:

• Function execution times
• Error logs
• Function invocations

This helps you ensure your microservices are running smoothly.

Conclusion: Serverless Microservices — The Future is Here

By now, you’ve built a fully functioning serverless microservice using Azure Functions. We’ve covered everything from setting up Azure Functions, writing your code, integrating with Cosmos DB, and scaling effortlessly.

Azure Functions not only simplifies the infrastructure but also empowers you to focus purely on business logic, making it an ideal choice for modern microservice architecture.

Next Steps: Ready to take your serverless architecture to the next level? In future posts, we’ll explore advanced scenarios like implementing event-driven microservices, using durable functions for state management, and optimizing cost with serverless pricing models.