Managing Weights & Biases ML Tracking on Azure with .NET SDK

Machine learning experiment tracking is essential for managing model development at scale, and Weights & Biases (W&B) provides powerful MLOps capabilities for experiment tracking, model registry, and hyperparameter optimization. The Azure integration enables unified billing through Azure Marketplace alongside native Azure resource management. This .NET SDK skill allows AI agents to programmatically provision W&B instances, configure single sign-on, and integrate ML tracking infrastructure with Azure-based deployments.

What This Skill Does

The azure-mgmt-weightsandbiases-dotnet skill provides .NET interfaces for managing Weights & Biases instances as Azure ARM resources. It handles instance creation with proper marketplace subscription linkage, single sign-on configuration through Azure Entra ID, administrator assignment, managed identity configuration for secure Azure integrations, and resource lifecycle operations including updates and deletion.

This skill enables agents to create W&B instances with Azure Marketplace billing integration, specify instance regions and custom subdomains for organization branding, configure SAML-based SSO with Entra ID for enterprise authentication, assign managed identities for secure access to other Azure resources, and list existing instances across resource groups and subscriptions for inventory management.

It's critical to understand this SDK manages the Azure-side W&B instance resource, not the ML experiments, runs, artifacts, or models directly. After provisioning the instance through this SDK, use the W&B Python SDK for actual experiment tracking and model management operations.

Getting Started

Install the Weights & Biases resource manager SDK as a preview package:

dotnet add package Azure.ResourceManager.WeightsAndBiases --prerelease
dotnet add package Azure.Identity

Configure environment variables for Azure resource targeting:

export AZURE_SUBSCRIPTION_ID="your-subscription-id"
export AZURE_RESOURCE_GROUP="your-resource-group"
export AZURE_WANDB_INSTANCE_NAME="your-wandb-instance"

Initialize the ARM client with authentication:

using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.WeightsAndBiases;

ArmClient client = new ArmClient(new DefaultAzureCredential());

Before creating W&B instances, you need a valid Azure Marketplace subscription for Weights & Biases. This typically involves accepting the W&B offer terms through the Azure portal or CLI first.

Key Features

Marketplace Integration: The SDK handles Azure Marketplace billing integration complexity. You provide marketplace subscription details including publisher ID ("wandb"), offer ID, plan ID, billing term unit, and term identifier. The SDK ensures proper linkage between your Azure subscription and the W&B service.

Region Selection: Deploy W&B instances in multiple Azure regions including East US, Central US, West US, West Europe, Japan East, and Korea Central. Choose regions based on your compute location to minimize latency for experiment logging.

Custom Subdomains: Configure custom subdomains for your W&B instance (e.g., "my-company-wandb.wandb.ai"). This provides branded URLs for your ML teams and isolates your experiments from other organizations.

Single Sign-On: Configure SAML-based SSO integration with Azure Entra ID for enterprise authentication. Specify Enterprise App IDs and allowed domains, enabling teams to access W&B using corporate credentials without separate password management.

Managed Identity: Enable system-assigned managed identities on W&B instances for secure access to other Azure resources like Azure Storage, Key Vault, or Compute without credential management. Managed identities follow Azure RBAC for fine-grained access control.

Long-Running Operations: Instance provisioning is a long-running operation that the SDK manages through completion polling with WaitUntil.Completed or manual polling with WaitUntil.Started for background processing scenarios.

Usage Examples

Creating a W&B instance with marketplace integration and managed identity:

using Azure.ResourceManager.WeightsAndBiases;
using Azure.ResourceManager.WeightsAndBiases.Models;

ResourceGroupResource resourceGroup = await client
    .GetDefaultSubscriptionAsync()
    .Result
    .GetResourceGroupAsync("ml-platform");

WeightsAndBiasesInstanceCollection instances = resourceGroup.GetWeightsAndBiasesInstances();

WeightsAndBiasesInstanceData data = new WeightsAndBiasesInstanceData(AzureLocation.EastUS)
{
    Properties = new WeightsAndBiasesInstanceProperties
    {
        Marketplace = new WeightsAndBiasesMarketplaceDetails
        {
            SubscriptionId = "marketplace-subscription-id",
            OfferDetails = new WeightsAndBiasesOfferDetails
            {
                PublisherId = "wandb",
                OfferId = "wandb-pay-as-you-go",
                PlanId = "wandb-payg",
                PlanName = "Pay As You Go",
                TermId = "monthly",
                TermUnit = "P1M"
            }
        },
        User = new WeightsAndBiasesUserDetails
        {
            FirstName = "ML",
            LastName = "Platform",
            EmailAddress = "[email protected]",
            Upn = "[email protected]"
        },
        PartnerProperties = new WeightsAndBiasesPartnerProperties
        {
            Region = WeightsAndBiasesRegion.EastUS,
            Subdomain = "acme-ml"
        }
    },
    Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.SystemAssigned),
    Tags = {
        ["Environment"] = "Production",
        ["Team"] = "ML-Platform"
    }
};

ArmOperation<WeightsAndBiasesInstanceResource> operation = await instances
    .CreateOrUpdateAsync(WaitUntil.Completed, "acme-wandb", data);

Console.WriteLine($"W&B URL: https://{data.Properties.PartnerProperties.Subdomain}.wandb.ai");

Configuring enterprise single sign-on with Entra ID:

WeightsAndBiasesInstanceResource instance = await resourceGroup
    .GetWeightsAndBiasesInstanceAsync("acme-wandb");

WeightsAndBiasesInstanceData updateData = instance.Data;

updateData.Properties.SingleSignOnPropertiesV2 = new WeightsAndBiasSingleSignOnPropertiesV2
{
    Type = WeightsAndBiasSingleSignOnType.Saml,
    State = WeightsAndBiasSingleSignOnState.Enable,
    EnterpriseAppId = "entra-enterprise-app-id",
    AadDomains = { "acme.com", "acme-research.com" }
};

await resourceGroup.GetWeightsAndBiasesInstances()
    .CreateOrUpdateAsync(WaitUntil.Completed, "acme-wandb", updateData);

Console.WriteLine("SSO configured - users can now login with Entra ID credentials");

Implementing cost allocation through resource tagging:

WeightsAndBiasesInstanceResource instance = await instances.GetAsync("acme-wandb");

WeightsAndBiasesInstancePatch patch = new WeightsAndBiasesInstancePatch
{
    Tags =
    {
        { "CostCenter", "ML-Research" },
        { "Project", "ImageClassification" },
        { "Owner", "DataScience" }
    }
};

await instance.UpdateAsync(patch);

Best Practices

Use DefaultAzureCredential for authentication to support multiple authentication methods including environment variables, managed identity, Azure CLI, and Visual Studio. This flexibility enables the same code to work in development, CI/CD, and production environments.

Enable managed identity on W&B instances that need to access other Azure resources. Managed identities eliminate credential management and provide better security through Azure RBAC. Use system-assigned identity for single-instance scenarios or user-assigned identity for shared identity across resources.

Configure single sign-on for enterprise deployments to eliminate password management overhead and improve security. SSO integration with Entra ID enables centralized access control, multi-factor authentication enforcement, and automated provisioning/deprovisioning as team members join or leave.

Store marketplace subscription details securely in Azure Key Vault rather than hardcoding them. Subscription IDs and term information should be treated as configuration data retrieved at runtime with proper access controls.

Check provisioning state after creation before proceeding with W&B SDK operations. Wait for Succeeded state before distributing the instance URL to teams or configuring experiment tracking in training pipelines.

Use appropriate regions based on your compute infrastructure location. Placing W&B instances close to training compute reduces latency for experiment logging, especially for high-frequency metrics updates during training.

Tag resources consistently for cost allocation and governance. Include environment type, team ownership, cost center, and project information. Tags enable filtering in Azure Cost Management and chargeback to appropriate business units.

When to Use This Skill

Use this skill when deploying ML infrastructure as part of Azure-based machine learning platforms. Teams training models on Azure compute who want unified billing and resource management should provision W&B instances through this SDK rather than directly through W&B's website.

It's ideal for platform teams building self-service ML infrastructure. Create internal APIs that allow data science teams to provision their own W&B instances through automation, with governance policies enforced through Azure tags and naming conventions.

The skill is valuable when integrating W&B into existing Azure DevOps or GitHub Actions pipelines. Automate instance creation as part of project setup workflows, ensuring experiment tracking infrastructure is provisioned consistently alongside compute and storage resources.

Use it for multi-environment ML infrastructure where each environment (dev, staging, production) needs isolated W&B instances. Programmatic management enables templated creation with environment-specific configurations and proper resource isolation.

When Not to Use This Skill

Don't use this skill for logging experiments, tracking metrics, or managing model artifacts. The W&B Python SDK handles those operational tasks. This SDK only provisions the Azure infrastructure where W&B experiments will be tracked.

If you're using W&B outside of Azure or prefer direct W&B account management, you don't need this SDK. The Azure integration is specifically for teams wanting unified billing through Azure Marketplace and resource management alongside other Azure services.

Avoid it for querying experiment results or downloading model artifacts. Those are data operations handled through W&B APIs and UI. This SDK focuses on provisioning the instance resource, not managing the ML experiments stored within it.

Don't use it for one-time instance creation that can be done through the Azure portal. The SDK adds value for automated, repeatable provisioning workflows, not for single manual operations.

Related Skills

• azure-mgmt-arizeaiobservabilityeval-dotnet - Manage Arize AI ML observability resources on Azure
• azure-mgmt-applicationinsights-dotnet - Provision Application Insights for model serving telemetry
• azure-monitor-query-py - Query training metrics and performance data

Source

This skill is provided by Microsoft as part of the Azure SDK for .NET. The Weights & Biases integration is developed in partnership with Weights & Biases for Azure Marketplace. Learn more at the NuGet package page, explore the GitHub source code, and review W&B documentation for experiment tracking features.