Managing Arize AI ML Observability Resources on Azure

Machine learning models degrade over time, and detecting issues early is critical for maintaining AI system reliability. Arize AI provides ML observability and evaluation capabilities, and the Azure integration enables teams to manage Arize resources directly through Azure. This .NET SDK skill allows AI agents to programmatically provision Arize AI organizations, manage marketplace subscriptions, and integrate ML monitoring into Azure-based infrastructure.

What This Skill Does

The azure-mgmt-arizeaiobservabilityeval-dotnet skill provides a .NET interface for managing Arize AI Observability and Evaluation resources within Azure. It handles the full lifecycle of Arize organizations purchased through Azure Marketplace, from initial provisioning with marketplace subscription details to configuration updates and eventual decommissioning.

This skill enables agents to create Arize AI organizations with proper marketplace billing integration, configure user access details, manage resource tags for cost allocation, and handle long-running provisioning operations asynchronously. It's specifically designed for teams deploying ML models on Azure who want unified billing and resource management alongside their existing Azure infrastructure.

The SDK abstracts the complexity of Azure Marketplace integrations, handling subscription IDs, offer details, publisher information, and provisioning state management. It provides both high-level operations for common tasks and granular control for advanced scenarios requiring custom configurations or conditional logic based on resource existence.

Getting Started

Install the NuGet package for Arize AI resource management:

dotnet add package Azure.ResourceManager.ArizeAIObservabilityEval --version 1.0.0

Configure Azure authentication using environment variables for service principal credentials:

export AZURE_SUBSCRIPTION_ID="your-subscription-id"
export AZURE_TENANT_ID="your-tenant-id"
export AZURE_CLIENT_ID="your-client-id"
export AZURE_CLIENT_SECRET="your-client-secret"

Authentication uses DefaultAzureCredential, which automatically discovers credentials from environment variables, managed identity, Azure CLI, or Visual Studio:

using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.ArizeAIObservabilityEval;

var credential = new DefaultAzureCredential();
var armClient = new ArmClient(credential);

Before creating Arize resources, you need a valid Azure Marketplace subscription for the Arize AI offer. This typically involves accepting the offer terms through the Azure portal or CLI first.

Key Features

Marketplace Integration: The SDK handles all the complexity of Azure Marketplace billing integration. You provide the marketplace subscription ID, publisher ID (arikimlabs1649082416596), offer ID (arize-liftr-1), plan details, and billing term information. The SDK ensures proper linkage between your Azure subscription and the Arize service.

Organization Lifecycle Management: Create, read, update, and delete Arize AI organizations within Azure resource groups. Organizations are the top-level container for Arize workspaces where ML model monitoring actually occurs. The SDK handles asynchronous provisioning, which can take several minutes for initial setup.

User Configuration: Specify user details (name, email) during organization creation. This information connects the Azure resource to the Arize user account that will administer the organization. The SDK validates user information format before submitting provisioning requests.

Conditional Operations: Methods like GetIfExistsAsync and ExistsAsync enable safe conditional logic without throwing exceptions. This is valuable for idempotent infrastructure-as-code scenarios where resources may or may not already exist.

Direct Resource Access: Beyond listing resources, the SDK supports direct resource access using resource identifiers. This optimization avoids unnecessary list operations when you already know the resource name and want to perform operations quickly.

Tag Management: Update resource tags independently of other properties using patch operations. Tags enable cost allocation, organizational policies, and resource filtering across Azure subscriptions.

Usage Examples

Creating an Arize AI organization with marketplace subscription linkage:

var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
var subscription = await armClient.GetSubscriptionResource(
    SubscriptionResource.CreateResourceIdentifier(subscriptionId)).GetAsync();
var resourceGroup = await subscription.Value.GetResourceGroupAsync("ml-platform");

var collection = resourceGroup.Value.GetArizeAIObservabilityEvalOrganizations();

var data = new ArizeAIObservabilityEvalOrganizationData(AzureLocation.EastUS)
{
    Properties = new ArizeAIObservabilityEvalOrganizationProperties
    {
        Marketplace = new ArizeAIObservabilityEvalMarketplaceDetails
        {
            SubscriptionId = "marketplace-sub-id",
            OfferDetails = new ArizeAIObservabilityEvalOfferDetails
            {
                PublisherId = "arikimlabs1649082416596",
                OfferId = "arize-liftr-1",
                PlanId = "arize-liftr-1-plan",
                PlanName = "Arize AI Plan",
                TermUnit = "P1M",
                TermId = "term-id"
            }
        },
        User = new ArizeAIObservabilityEvalUserDetails
        {
            FirstName = "ML",
            LastName = "Platform",
            EmailAddress = "[email protected]"
        }
    },
    Tags = { ["environment"] = "production", ["team"] = "ml-ops" }
};

var operation = await collection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "arize-prod",
    data);

Safely checking for resource existence before creating:

var exists = await collection.ExistsAsync("arize-dev");
if (!exists.Value)
{
    var data = new ArizeAIObservabilityEvalOrganizationData(AzureLocation.EastUS)
    {
        // configuration details
    };
    await collection.CreateOrUpdateAsync(WaitUntil.Completed, "arize-dev", data);
}

Updating tags on an existing organization:

var org = await collection.GetAsync("arize-prod");
var updateData = new ArizeAIObservabilityEvalOrganizationPatch
{
    Tags = { ["cost-center"] = "ml-research", ["version"] = "v2" }
};
await org.Value.UpdateAsync(updateData);

Best Practices

Always use async methods with proper await patterns. All SDK operations are asynchronous to avoid blocking threads during network calls, which is especially important for long-running operations like resource provisioning that can take several minutes.

Handle long-running operations explicitly by choosing between WaitUntil.Completed for synchronous-style behavior or WaitUntil.Started for background processing with manual polling. Most infrastructure provisioning should use WaitUntil.Completed to ensure resources are ready before dependent operations proceed.

Use GetIfExistsAsync instead of catching exceptions for conditional logic. Exception handling is expensive, and checking existence explicitly makes code intent clearer and performs better when resources frequently don't exist.

Implement retry policies through ArmClientOptions for transient failures. Azure services can experience temporary issues, and proper retry configuration with exponential backoff ensures operations eventually succeed without manual intervention.

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

Use resource identifiers for direct access when you know the exact resource name. Direct access via CreateResourceIdentifier avoids listing operations and reduces API calls, improving performance in large-scale deployments.

Close ARM clients properly using using statements or explicit disposal. While the SDK handles cleanup internally, proper resource management prevents connection leaks in long-running applications.

When to Use This Skill

Use this skill when deploying ML observability infrastructure as code alongside model deployments. If your team trains and deploys ML models on Azure, provisioning Arize resources programmatically ensures monitoring is configured consistently across all model environments.

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

The skill is valuable when integrating Arize into existing Azure DevOps or GitHub Actions pipelines. Automate the creation of Arize organizations for each new ML project, link them to appropriate Azure subscriptions, and configure user access as part of project setup workflows.

Use it for managing multi-environment ML infrastructure where each environment (dev, staging, production) needs isolated Arize organizations. Programmatic management enables templated creation with environment-specific configurations.

When Not to Use This Skill

Don't use this skill for sending ML telemetry to Arize. The Arize Python SDK or REST API handles model predictions, ground truth data, and feature logging. This resource manager SDK only provisions the Azure infrastructure where that data will be stored and analyzed.

If you're using Arize outside of Azure or prefer direct Arize 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 one-time organization creation that can be done through the Azure portal. The SDK adds value for automated, repeatable provisioning workflows, not for single manual operations.

Don't use it for querying ML observability data or configuring monitors. The Arize platform APIs and UI handle operational monitoring tasks. This SDK focuses on provisioning and managing the Azure resource containers.

Related Skills

• azure-mgmt-applicationinsights-dotnet - Provision Azure Application Insights for traditional app monitoring
• azure-monitor-opentelemetry-exporter-py - Export telemetry to Azure Monitor
• azure-mgmt-weightsandbiases-dotnet - Manage Weights & Biases ML experiment tracking on Azure

Source

This skill is provided by Microsoft as part of the Azure SDK for .NET. The Arize AI integration is developed in partnership with Arize AI for Azure Marketplace. Learn more at the NuGet package page and explore Arize AI's ML observability capabilities at arize.com.