Writing a Go Service for Azure Cosmos DB Management

Introduction
Prerequisites
Setting Up Azure Cosmos DB
Creating Go Service
Handling Concurrency
Conclusion

Introduction

In this tutorial, we will learn how to write a Go service for managing Azure Cosmos DB. We will cover the setup process for Azure Cosmos DB and then dive into creating a Go service that interacts with the database. By the end of this tutorial, you will have a basic understanding of how to handle concurrency and perform CRUD operations on Azure Cosmos DB using Go.

Prerequisites

Before starting this tutorial, you should have:

Basic knowledge of Go programming language
An active Azure account
Azure Cosmos DB resource created

Setting Up Azure Cosmos DB

Log in to your Azure portal.
Create a new Azure Cosmos DB resource.
Select the appropriate API for your application (e.g., SQL API, MongoDB API, etc.).
Choose a unique name for your database account.
Set the desired subscription, resource group, and location.
Click on “Review + create” and then “Create” to create the Azure Cosmos DB resource.

Creating Go Service

Create a new directory for your Go project.
Open a terminal and navigate to the project directory.

Initialize Go module by running the following command:

 go mod init github.com/your-username/go-cosmos-service

Create a new Go file, e.g., main.go, and open it in your preferred text editor.

Import the necessary packages:

 package main
    
 import (
 	"context"
 	"fmt"
 	"log"
    
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
 	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
 )

Define the necessary constants for Azure Cosmos DB:

 const (
 	endpoint    = "https://your-db-account.documents.azure.com:443/"
 	masterKey   = "your-db-account-master-key"
 	dbName      = "your-db-name"
 	containerID = "your-container-id"
 )

Implement a function to create a new Container in Azure Cosmos DB:

 func createContainer(ctx context.Context) (*azcosmos.Container, error) {
 	client, err := azcosmos.NewClient(endpoint, masterKey, nil)
 	if err != nil {
 		return nil, err
 	}
    
 	db := client.NewDatabase(dbName)
 	container := db.NewContainer(containerID)
    
 	options := azcosmos.ContainerOptions{
 		Throughput: 400, // Adjust as per your requirements
 	}
    
 	resp, err := container.Create(ctx, options)
 	if err != nil {
 		return nil, err
 	}
    
 	fmt.Printf("Created container '%s' with ID '%s'\n", resp.DatabaseID, resp.ContainerID)
    
 	return container, nil
 }

Implement a function to insert a document into the container:

 func insertDocument(ctx context.Context, container *azcosmos.Container, document interface{}) error {
 	resp, err := container.CreateItem(ctx, document, nil)
 	if err != nil {
 		return err
 	}
    
 	fmt.Printf("Inserted document with ID '%s'\n", resp.ItemID)
    
 	return nil
 }

Implement the main function to orchestrate the service:

 func main() {
 	ctx := context.Background()
    
 	container, err := createContainer(ctx)
 	if err != nil {
 		log.Fatal(err)
 	}
    
 	document := map[string]interface{}{
 		"id":   "1",
 		"name": "John Doe",
 	}
    
 	err = insertDocument(ctx, container, document)
 	if err != nil {
 		log.Fatal(err)
 	}
 }

Save and close the main.go file.
Build and run the Go service:
```
go build
./your-project-binary
```

Handling Concurrency

To handle concurrency in our Go service, we can utilize goroutines and channels. For example, let’s modify our insertDocument function to insert multiple documents concurrently:

func insertDocumentsConcurrently(ctx context.Context, container *azcosmos.Container, documents []interface{}) error {
	ch := make(chan error)

	for _, document := range documents {
		go func(doc interface{}) {
			err := insertDocument(ctx, container, doc)
			ch <- err
		}(document)
	}

	for range documents {
		err := <-ch
		if err != nil {
			return err
		}
	}

	return nil
}

To use the concurrent insertion, update the main function as follows:

func main() {
	ctx := context.Background()

	container, err := createContainer(ctx)
	if err != nil {
		log.Fatal(err)
	}

	documents := []interface{}{
		map[string]interface{}{"id": "1", "name": "John Doe"},
		map[string]interface{}{"id": "2", "name": "Jane Smith"},
	}

	err = insertDocumentsConcurrently(ctx, container, documents)
	if err != nil {
		log.Fatal(err)
	}
}

Conclusion

In this tutorial, we learned how to write a Go service for managing Azure Cosmos DB. We covered the setup process for Azure Cosmos DB and explored creating a Go service that interacts with the database. Additionally, we looked at how to handle concurrency using goroutines and channels. You can further enhance this service by implementing other CRUD operations and integrating it with your application.

Remember to clean up any unused resources to avoid unnecessary costs, as well as to apply error handling, logging, and appropriate best practices in a production environment.

Happy coding!

Published: 1 February 2020