or run

tessl search

Version

Workspace: tessl
Visibility: Public
Created: 6 days ago
Last updated: about 16 hours ago
Describes: pkg:golang/github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus@v1.10.0

docs

admin

index.md queues.md rules.md subscriptions.md topics.md

client.md errors.md index.md messaging.md receiver.md sender.md sessions.md

tile.json

tessl/golang-github-com--azure--azure-sdk-for-go--sdk--messaging--azservicebus

tessl install tessl/golang-github-com--azure--azure-sdk-for-go--sdk--messaging--azservicebus@1.10.1

Client module for Azure Service Bus, a highly reliable cloud messaging service providing real-time and fault-tolerant communication between distributed senders and receivers.

Entity Management (Admin Client)

The admin.Client provides methods for creating, updating, deleting, and querying Service Bus entities including queues, topics, subscriptions, and rules. This is separate from the messaging client and is used for administrative operations.

Package Information

Package Name: github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus/admin
Import: import "github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus/admin"

Capabilities

Admin Client Creation

Create an admin client using Azure identity credentials or a connection string.

Using Azure Identity

func NewClient(fullyQualifiedNamespace string, tokenCredential azcore.TokenCredential, options *ClientOptions) (*Client, error)

Creates an admin client using token-based authentication. The fullyQualifiedNamespace is the Service Bus namespace (e.g., "myservicebus.servicebus.windows.net").

Example:

import (
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus/admin"
)

credential, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
    panic(err)
}

adminClient, err := admin.NewClient(
    "myservicebus.servicebus.windows.net",
    credential,
    nil,
)
if err != nil {
    panic(err)
}

Using Connection String

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

Creates an admin client using a connection string with SharedAccessKeyName and SharedAccessKey:

Endpoint=sb://<sb>.servicebus.windows.net/;SharedAccessKeyName=<key name>;SharedAccessKey=<key value>

Or with SharedAccessSignature:

Endpoint=sb://<sb>.servicebus.windows.net;SharedAccessSignature=SharedAccessSignature sr=<sb>.servicebus.windows.net&sig=<base64-sig>&se=<expiry>&skn=<keyname>

Example:

adminClient, err := admin.NewClientFromConnectionString(
    "Endpoint=sb://myservicebus.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=...",
    nil,
)

Namespace Operations

Get Namespace Properties

func (ac *Client) GetNamespaceProperties(ctx context.Context, options *GetNamespacePropertiesOptions) (GetNamespacePropertiesResponse, error)

Retrieves namespace properties including SKU, creation time, and messaging units.

Example:

resp, err := adminClient.GetNamespaceProperties(context.Background(), nil)
if err != nil {
    panic(err)
}

fmt.Printf("Namespace: %s\n", resp.Name)
fmt.Printf("SKU: %s\n", resp.SKU)
fmt.Printf("Created: %s\n", resp.CreatedTime)
if resp.MessagingUnits != nil {
    fmt.Printf("Messaging Units: %d\n", *resp.MessagingUnits)
}

Queue Operations

The admin client provides full CRUD operations for queues.

Create Queue

func (ac *Client) CreateQueue(ctx context.Context, queueName string, options *CreateQueueOptions) (CreateQueueResponse, error)

Creates a queue with configurable properties.

Example:

resp, err := adminClient.CreateQueue(context.Background(), "myqueue", &admin.CreateQueueOptions{
    Properties: &admin.QueueProperties{
        MaxDeliveryCount:                 to.Ptr(int32(5)),
        LockDuration:                     to.Ptr("PT1M"),  // 1 minute
        DefaultMessageTimeToLive:         to.Ptr("P14D"),  // 14 days
        DeadLetteringOnMessageExpiration: to.Ptr(true),
        EnablePartitioning:               to.Ptr(true),
    },
})
if err != nil {
    panic(err)
}

fmt.Printf("Created queue: %s\n", resp.QueueName)

Get Queue

func (ac *Client) GetQueue(ctx context.Context, queueName string, options *GetQueueOptions) (*GetQueueResponse, error)

Gets queue properties by name. Returns nil response and nil error if the queue does not exist.

Get Queue Runtime Properties

func (ac *Client) GetQueueRuntimeProperties(ctx context.Context, queueName string, options *GetQueueRuntimePropertiesOptions) (*GetQueueRuntimePropertiesResponse, error)

Gets runtime properties like message counts and queue size. Returns nil response and nil error if the queue does not exist.

Update Queue

func (ac *Client) UpdateQueue(ctx context.Context, queueName string, properties QueueProperties, options *UpdateQueueOptions) (UpdateQueueResponse, error)

Updates an existing queue's properties.

Delete Queue

func (ac *Client) DeleteQueue(ctx context.Context, queueName string, options *DeleteQueueOptions) (DeleteQueueResponse, error)

Deletes a queue.

List Queues

func (ac *Client) NewListQueuesPager(options *ListQueuesOptions) *runtime.Pager[ListQueuesResponse]

Creates a pager for listing all queues.

Example:

pager := adminClient.NewListQueuesPager(&admin.ListQueuesOptions{
    MaxPageSize: 10,
})

for pager.More() {
    page, err := pager.NextPage(context.Background())
    if err != nil {
        panic(err)
    }

    for _, queue := range page.Queues {
        fmt.Printf("Queue: %s\n", queue.QueueName)
    }
}

List Queue Runtime Properties

func (ac *Client) NewListQueuesRuntimePropertiesPager(options *ListQueuesRuntimePropertiesOptions) *runtime.Pager[ListQueuesRuntimePropertiesResponse]

Creates a pager for listing runtime properties of all queues.

Queue Management Details

Topic Operations

The admin client provides full CRUD operations for topics.

Create Topic

func (ac *Client) CreateTopic(ctx context.Context, topicName string, options *CreateTopicOptions) (CreateTopicResponse, error)

Creates a topic with configurable properties.

Get Topic

func (ac *Client) GetTopic(ctx context.Context, topicName string, options *GetTopicOptions) (*GetTopicResponse, error)

Gets topic properties by name. Returns nil response and nil error if the topic does not exist.

Get Topic Runtime Properties

func (ac *Client) GetTopicRuntimeProperties(ctx context.Context, topicName string, options *GetTopicRuntimePropertiesOptions) (*GetTopicRuntimePropertiesResponse, error)

Gets runtime properties like subscription count and topic size. Returns nil response and nil error if the topic does not exist.

Update Topic

func (ac *Client) UpdateTopic(ctx context.Context, topicName string, properties TopicProperties, options *UpdateTopicOptions) (UpdateTopicResponse, error)

Updates an existing topic's properties.

Delete Topic

func (ac *Client) DeleteTopic(ctx context.Context, topicName string, options *DeleteTopicOptions) (DeleteTopicResponse, error)

Deletes a topic and all its subscriptions.

List Topics

func (ac *Client) NewListTopicsPager(options *ListTopicsOptions) *runtime.Pager[ListTopicsResponse]

Creates a pager for listing all topics.

List Topic Runtime Properties

func (ac *Client) NewListTopicsRuntimePropertiesPager(options *ListTopicsRuntimePropertiesOptions) *runtime.Pager[ListTopicsRuntimePropertiesResponse]

Creates a pager for listing runtime properties of all topics.

Topic Management Details

Subscription Operations

The admin client provides full CRUD operations for subscriptions.

Create Subscription

func (ac *Client) CreateSubscription(ctx context.Context, topicName, subscriptionName string, options *CreateSubscriptionOptions) (CreateSubscriptionResponse, error)

Creates a subscription to a topic with configurable properties.

Example:

resp, err := adminClient.CreateSubscription(
    context.Background(),
    "mytopic",
    "mysubscription",
    &admin.CreateSubscriptionOptions{
        Properties: &admin.SubscriptionProperties{
            LockDuration:                     to.Ptr("PT30S"),
            DefaultMessageTimeToLive:         to.Ptr("P7D"),
            DeadLetteringOnMessageExpiration: to.Ptr(true),
            MaxDeliveryCount:                 to.Ptr(int32(3)),
        },
    },
)
if err != nil {
    panic(err)
}

fmt.Printf("Created subscription: %s on topic: %s\n", resp.SubscriptionName, resp.TopicName)

Get Subscription

func (ac *Client) GetSubscription(ctx context.Context, topicName, subscriptionName string, options *GetSubscriptionOptions) (*GetSubscriptionResponse, error)

Gets subscription properties. Returns nil response and nil error if the subscription does not exist.

Get Subscription Runtime Properties

func (ac *Client) GetSubscriptionRuntimeProperties(ctx context.Context, topicName, subscriptionName string, options *GetSubscriptionRuntimePropertiesOptions) (*GetSubscriptionRuntimePropertiesResponse, error)

Gets runtime properties like message counts. Returns nil response and nil error if the subscription does not exist.

Update Subscription

func (ac *Client) UpdateSubscription(ctx context.Context, topicName, subscriptionName string, properties SubscriptionProperties, options *UpdateSubscriptionOptions) (UpdateSubscriptionResponse, error)

Updates an existing subscription's properties.

Delete Subscription

func (ac *Client) DeleteSubscription(ctx context.Context, topicName, subscriptionName string, options *DeleteSubscriptionOptions) (DeleteSubscriptionResponse, error)

Deletes a subscription.

List Subscriptions

func (ac *Client) NewListSubscriptionsPager(topicName string, options *ListSubscriptionsOptions) *runtime.Pager[ListSubscriptionsResponse]

Creates a pager for listing all subscriptions for a topic.

List Subscription Runtime Properties

func (ac *Client) NewListSubscriptionsRuntimePropertiesPager(topicName string, options *ListSubscriptionsRuntimePropertiesOptions) *runtime.Pager[ListSubscriptionsRuntimePropertiesResponse]

Creates a pager for listing runtime properties of all subscriptions for a topic.

Subscription Management Details

Rule Operations

The admin client provides full CRUD operations for subscription rules (filters).

Create Rule

func (ac *Client) CreateRule(ctx context.Context, topicName, subscriptionName string, options *CreateRuleOptions) (CreateRuleResponse, error)

Creates a rule that filters and optionally modifies messages for a subscription.

Example:

// Create SQL filter rule
resp, err := adminClient.CreateRule(
    context.Background(),
    "mytopic",
    "mysubscription",
    &admin.CreateRuleOptions{
        Name: to.Ptr("HighPriorityFilter"),
        Filter: &admin.SQLFilter{
            Expression: "priority > 5",
        },
    },
)

Get Rule

func (ac *Client) GetRule(ctx context.Context, topicName, subscriptionName, ruleName string, options *GetRuleOptions) (*GetRuleResponse, error)

Gets a rule for a subscription.

Update Rule

func (ac *Client) UpdateRule(ctx context.Context, topicName, subscriptionName string, properties RuleProperties) (UpdateRuleResponse, error)

Updates an existing rule's properties.

Delete Rule

func (ac *Client) DeleteRule(ctx context.Context, topicName, subscriptionName, ruleName string, options *DeleteRuleOptions) (DeleteRuleResponse, error)

Deletes a rule from a subscription.

List Rules

func (ac *Client) NewListRulesPager(topicName, subscriptionName string, options *ListRulesOptions) *runtime.Pager[ListRulesResponse]

Creates a pager for listing all rules for a subscription.

Example:

pager := adminClient.NewListRulesPager("mytopic", "mysubscription", nil)

for pager.More() {
    page, err := pager.NextPage(context.Background())
    if err != nil {
        panic(err)
    }

    for _, rule := range page.Rules {
        fmt.Printf("Rule: %s\n", rule.Name)
    }
}

Rule Management Details

Types

Client

type Client struct {
    // ... unexported fields
}

Admin client for entity management operations.

ClientOptions

type ClientOptions struct {
    // Embeds azcore.ClientOptions
}

Options for admin client creation. Inherits all options from azcore.ClientOptions.

NamespaceProperties

type NamespaceProperties struct {
    CreatedTime time.Time
    ModifiedTime time.Time
    SKU string
    MessagingUnits *int64
    Name string
}

Properties associated with a Service Bus namespace:

CreatedTime: When the namespace was created
ModifiedTime: When the namespace was last modified
SKU: Namespace SKU tier (Basic, Standard, or Premium)
MessagingUnits: Number of messaging units (Premium tier only)
Name: Namespace name

RetryOptions

type RetryOptions struct {
    MaxRetries int
    RetryDelay time.Duration
    MaxRetryDelay time.Duration
}

Retry configuration for admin operations (shared with main package).

Usage Patterns

Create Complete Topic with Subscriptions and Rules

// Create topic
topic, err := adminClient.CreateTopic(context.Background(), "orders", &admin.CreateTopicOptions{
    Properties: &admin.TopicProperties{
        EnablePartitioning: to.Ptr(true),
        MaxSizeInMegabytes: to.Ptr(int32(5120)),
    },
})

// Create subscription with correlation filter
_, err = adminClient.CreateSubscription(
    context.Background(),
    "orders",
    "high-value-orders",
    &admin.CreateSubscriptionOptions{
        Properties: &admin.SubscriptionProperties{
            DefaultMessageTimeToLive: to.Ptr("P7D"),
        },
    },
)

// Add filter rule
_, err = adminClient.CreateRule(
    context.Background(),
    "orders",
    "high-value-orders",
    &admin.CreateRuleOptions{
        Name: to.Ptr("HighValueFilter"),
        Filter: &admin.SQLFilter{
            Expression: "amount > @threshold",
            Parameters: map[string]any{
                "threshold": 1000.0,
            },
        },
    },
)

Monitor Queue Metrics

func monitorQueue(adminClient *admin.Client, queueName string) {
    resp, err := adminClient.GetQueueRuntimeProperties(context.Background(), queueName, nil)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Queue: %s\n", resp.QueueName)
    fmt.Printf("Active Messages: %d\n", resp.ActiveMessageCount)
    fmt.Printf("Dead Letter Messages: %d\n", resp.DeadLetterMessageCount)
    fmt.Printf("Scheduled Messages: %d\n", resp.ScheduledMessageCount)
    fmt.Printf("Size: %d bytes\n", resp.SizeInBytes)
    fmt.Printf("Last Updated: %s\n", resp.UpdatedAt)
}

Update Queue Configuration

// Get current properties
queueResp, err := adminClient.GetQueue(context.Background(), "myqueue", nil)
if err != nil {
    panic(err)
}

// Modify properties
props := queueResp.QueueProperties
props.MaxDeliveryCount = to.Ptr(int32(10))
props.LockDuration = to.Ptr("PT2M")

// Update queue
_, err = adminClient.UpdateQueue(context.Background(), "myqueue", props, nil)
if err != nil {
    panic(err)
}

List All Entities

func listAllEntities(adminClient *admin.Client) {
    // List all queues
    fmt.Println("Queues:")
    queuePager := adminClient.NewListQueuesPager(nil)
    for queuePager.More() {
        page, _ := queuePager.NextPage(context.Background())
        for _, queue := range page.Queues {
            fmt.Printf("  - %s\n", queue.QueueName)
        }
    }

    // List all topics
    fmt.Println("Topics:")
    topicPager := adminClient.NewListTopicsPager(nil)
    for topicPager.More() {
        page, _ := topicPager.NextPage(context.Background())
        for _, topic := range page.Topics {
            fmt.Printf("  - %s\n", topic.TopicName)

            // List subscriptions for each topic
            subPager := adminClient.NewListSubscriptionsPager(topic.TopicName, nil)
            for subPager.More() {
                subPage, _ := subPager.NextPage(context.Background())
                for _, sub := range subPage.Subscriptions {
                    fmt.Printf("      -> %s\n", sub.SubscriptionName)
                }
            }
        }
    }
}

Version

tessl/golang-github-com--azure--azure-sdk-for-go--sdk--messaging--azservicebus

index.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/admin/

Entity Management (Admin Client)

Package Information

Capabilities

Admin Client Creation

Using Azure Identity

Using Connection String

Namespace Operations

Get Namespace Properties

Queue Operations

Create Queue

Get Queue

Get Queue Runtime Properties

Update Queue

Delete Queue

List Queues

List Queue Runtime Properties

Topic Operations

Create Topic

Get Topic

Get Topic Runtime Properties

Update Topic

Delete Topic

List Topics

List Topic Runtime Properties

Subscription Operations

Create Subscription

Get Subscription

Get Subscription Runtime Properties

Update Subscription

Delete Subscription

List Subscriptions

List Subscription Runtime Properties

Rule Operations

Create Rule

Get Rule

Update Rule

Delete Rule

List Rules

Types

Client

ClientOptions

NamespaceProperties

RetryOptions

Usage Patterns

Create Complete Topic with Subscriptions and Rules

Monitor Queue Metrics

Update Queue Configuration

List All Entities

index.mddocs/admin/