MSDN / Azure / SDK / Go / azqueue

Azure SDK for Go - azqueue Module

Interact with Azure Queue Storage services seamlessly.

Overview

The azqueue module in the Azure SDK for Go provides a robust and idiomatic way to interact with Azure Queue Storage. Azure Queue Storage is a service that stores large numbers of small messages. You can access these messages from anywhere in the world via HTTP or HTTPS. A queue can contain any number of messages.

This module simplifies common queue operations such as sending messages, receiving messages, dequeuing messages, and managing queues and their metadata.

Core Concepts

Key Features

Getting Started

To use the azqueue module, you'll need to install it first: 


go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
go get github.com/Azure/azure-sdk-for-go/sdk/azcore/to
go get github.com/Azure/azure-sdk-for-go/sdk/storage/azqueue

Authentication

Authentication is typically handled using Azure Identity credentials. 


import (
    "context"
    "log"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/storage/azqueue"
)

func main() {
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("failed to obtain a credential: %v", err)
    }

    // Replace with your Azure Storage Account Name
    accountName := "yourstorageaccountname"
    // The Queue endpoint is typically: https://{accountName}.queue.core.windows.net

    // You can also use a connection string directly:
    // connStr := "DefaultEndpointsProtocol=https;AccountName=yourstorageaccountname;AccountKey=youraccountkey;EndpointSuffix=core.windows.net"
    // queueClient, err := azqueue.NewClientFromConnectionString(connStr, nil)


    queueServiceClient, err := azqueue.NewServiceClient(accountName, cred, nil)
    if err != nil {
        log.Fatalf("failed to create queue service client: %v", err)
    }

    ctx := context.Background()
    queueName := "my-test-queue"

    // Create a new queue client for the specific queue
    queueClient, err := queueServiceClient.NewClient(queueName)
    if err != nil {
        log.Fatalf("failed to create queue client: %v", err)
    }

    // Example usage follows...
}

API Reference

Client: azqueue.Client

Represents a client for a specific Azure Queue Storage queue.

NewClient(queueName string, serviceClient *azqueue.ServiceClient, options *azqueue.ClientOptions) (*azqueue.Client, error)

func (serviceClient *ServiceClient) NewClient(queueName string, options *ClientOptions) (*Client, error)

Creates a new client for a specific queue within the service client's account.

NewClientFromConnectionString(connectionString string, options *ClientOptions) (*Client, error)

func NewClientFromConnectionString(connectionString string, options *ClientOptions) (*Client, error)

Creates a new client from a connection string.

Methods on azqueue.Client

EnqueueMessage(ctx context.Context, messageText string, options *EnqueueMessageOptions) (EnqueueMessageResponse, error)

func (client *Client) EnqueueMessage(ctx context.Context, messageText string, options *EnqueueMessageOptions) (EnqueueMessageResponse, error)

Adds a message to the specified queue.

messageText: string - The text of the message to enqueue.
options: *EnqueueMessageOptions - Optional settings for the enqueue operation.
Returns: EnqueueMessageResponse - The response containing details of the enqueued message.

ReceiveMessages(ctx context.Context, options *ReceiveMessagesOptions) (ReceiveMessagesResponse, error)

func (client *Client) ReceiveMessages(ctx context.Context, options *ReceiveMessagesOptions) (ReceiveMessagesResponse, error)

Retrieves one or more messages from the front of the queue, but does not delete them.

options: *ReceiveMessagesOptions - Optional settings, such as the number of messages to retrieve and the visibility timeout.
Returns: ReceiveMessagesResponse - The response containing the received messages.

DeleteMessage(ctx context.Context, popReceipt string, messageID string, options *DeleteMessageOptions) (DeleteMessageResponse, error)

func (client *Client) DeleteMessage(ctx context.Context, popReceipt string, messageID string, options *DeleteMessageOptions) (DeleteMessageResponse, error)

Deletes a specific message from the queue.

popReceipt: string - The pop receipt value returned when the message was dequeued.
messageID: string - The ID of the message to delete.
options: *DeleteMessageOptions - Optional settings.
Returns: DeleteMessageResponse - The response indicating the success of the deletion.

UpdateMessage(ctx context.Context, popReceipt string, messageID string, options *UpdateMessageOptions) (UpdateMessageResponse, error)

func (client *Client) UpdateMessage(ctx context.Context, popReceipt string, messageID string, options *UpdateMessageOptions) (UpdateMessageResponse, error)

Updates the visibility of a message. This is useful for extending the time-out on a message that is being processed.

popReceipt: string - The pop receipt value returned when the message was dequeued.
messageID: string - The ID of the message to update.
options: *UpdateMessageOptions - Optional settings, including the new visibility timeout and message text.
Returns: UpdateMessageResponse - The response containing the updated message details.

CreateQueue(ctx context.Context, options *CreateQueueOptions) (CreateQueueResponse, error)

func (serviceClient *ServiceClient) CreateQueue(ctx context.Context, options *CreateQueueOptions) (CreateQueueResponse, error)

Creates a new queue under the specified account.

options: *CreateQueueOptions - Optional settings for queue creation.
Returns: CreateQueueResponse - The response confirming queue creation.

Example: Processing Messages

This example demonstrates receiving, processing, and deleting messages from a queue. 


import (
    "context"
    "log"
    "time"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/storage/azqueue"
)

func main() {
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("failed to obtain a credential: %v", err)
    }
    accountName := "yourstorageaccountname" // Replace with your storage account name

    queueServiceClient, err := azqueue.NewServiceClient(accountName, cred, nil)
    if err != nil {
        log.Fatalf("failed to create queue service client: %v", err)
    }

    queueName := "my-processing-queue"
    queueClient, err := queueServiceClient.NewClient(queueName)
    if err != nil {
        log.Fatalf("failed to create queue client: %v", err)
    }

    ctx := context.Background()

    // Send a sample message
    _, err = queueClient.EnqueueMessage(ctx, "Process this task!", &azqueue.EnqueueMessageOptions{
        MessageText: to.Ptr("Process this task!"), // Use to.Ptr from "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
    })
    if err != nil {
        log.Fatalf("failed to enqueue message: %v", err)
    }
    log.Println("Message enqueued.")

    // Try to receive messages
    resp, err := queueClient.ReceiveMessages(ctx, &azqueue.ReceiveMessagesOptions{
        NumberOfMessages: to.Ptr(int32(1)),
        // Set a reasonable visibility timeout so messages aren't lost if processing fails
        VisibilityTimeout: to.Ptr(int32(30)), // 30 seconds
    })
    if err != nil {
        log.Fatalf("failed to receive messages: %v", err)
    }

    if len(resp.Messages) > 0 {
        message := resp.Messages[0]
        log.Printf("Received message: ID=%s, Text=%s\n", *message.MessageID, *message.MessageText)

        // Simulate processing the message
        log.Println("Processing message...")
        time.Sleep(2 * time.Second)
        log.Println("Message processed successfully.")

        // Delete the message
        _, err = queueClient.DeleteMessage(ctx, *message.PopReceipt, *message.MessageID, nil)
        if err != nil {
            log.Fatalf("failed to delete message: %v", err)
        }
        log.Println("Message deleted.")
    } else {
        log.Println("No messages in the queue.")
    }
}