Managing Microsoft Fabric Capacities with .NET SDK

Microsoft Fabric is Microsoft's unified analytics platform combining Power BI, Data Factory, Synapse, and other data services. At its core are compute capacities that determine performance and billing. The Azure Resource Manager SDK for .NET enables AI agents to programmatically provision these capacities, scale them based on workload demands, suspend them during idle periods, and manage the complete lifecycle without manual portal interactions.

What This Skill Does

The azure-mgmt-fabric-dotnet skill provides management plane operations for Microsoft Fabric capacity resources through the .NET SDK. It handles capacity provisioning with specific SKU configurations, scaling operations between different capacity sizes, suspend and resume operations for cost management, administrator assignment for capacity governance, and name availability checks before resource creation.

This skill enables agents to create Fabric capacities with F-series SKUs ranging from F2 (2 capacity units) to F2048 (2048 capacity units), manage the capacity lifecycle including long-running provisioning operations that can take 5-15 minutes, check which SKUs are available in specific Azure regions, suspend capacities when not in use to stop compute billing, and list existing capacities across resource groups and subscriptions for inventory management.

It's important to note this SDK manages capacity resources only, not the data plane operations like creating workspaces, lakehouses, warehouses, or data items. Those operations use the Microsoft Fabric REST API or data plane SDKs accessed after capacity provisioning.

Getting Started

Install the Fabric resource manager SDK and Azure Identity library:

dotnet add package Azure.ResourceManager.Fabric
dotnet add package Azure.Identity

Configure environment variables for authentication:

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

Initialize the ARM client with DefaultAzureCredential:

using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Fabric;

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

var subscription = await armClient.GetDefaultSubscriptionAsync();

Before creating capacities, ensure you have appropriate Azure quotas and understand that capacity names must be globally unique across all Azure subscriptions.

Key Features

Capacity Provisioning: Create Fabric capacities with full control over SKU selection, Azure region placement, administrator assignments, and resource tagging. The SDK handles long-running provisioning operations that typically complete within 5-15 minutes, returning capacity details including provisioning state and resource endpoints.

SKU Management: The SDK supports all F-series SKUs from F2 through F2048, with capacity units (CUs) corresponding to the numerical suffix. List available SKUs for specific regions before provisioning to ensure your desired configuration is supported. Query existing capacities for their scalability options to determine valid upgrade paths.

Scaling Operations: Update capacity SKUs to scale up or down based on workload demands. Scaling is a long-running operation that may involve downtime, and the SDK properly handles the asynchronous nature with completion polling. Valid scale targets can be queried from existing capacities to avoid invalid configuration attempts.

Suspend and Resume: Suspend capacities during idle periods to stop compute billing while retaining the resource configuration and associated workspaces. Resume operations bring capacities back to active state with full functionality restored. These operations are long-running and properly managed through the SDK's async patterns.

Administrator Management: Specify capacity administrators using user principal names (UPNs) or Azure AD object IDs. Administrators can create workspaces, assign workloads, and manage capacity settings. Update administrator lists without recreating the capacity resource.

Name Availability: Check if capacity names are available before attempting creation. Since capacity names must be globally unique, this validation prevents provisioning failures and enables automated retry logic with alternative names.

Usage Examples

Creating a production Fabric capacity with proper configuration:

using Azure.ResourceManager.Fabric;
using Azure.ResourceManager.Fabric.Models;
using Azure.Core;

var resourceGroup = await subscription.Value
    .GetResourceGroupAsync("analytics-platform");

var administration = new FabricCapacityAdministration(
    new[] { "[email protected]", "[email protected]" }
);

var properties = new FabricCapacityProperties(administration);
var sku = new FabricSku("F64", FabricSkuTier.Fabric);

var capacityData = new FabricCapacityData(
    AzureLocation.WestUS2,
    properties,
    sku)
{
    Tags = { 
        ["Environment"] = "Production",
        ["CostCenter"] = "Analytics",
        ["ManagedBy"] = "AutomationAgent"
    }
};

var capacityCollection = resourceGroup.Value.GetFabricCapacities();
var operation = await capacityCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "prod-fabric-capacity",
    capacityData);

Console.WriteLine($"Provisioning state: {operation.Value.Data.Properties.ProvisioningState}");
Console.WriteLine($"Resource state: {operation.Value.Data.Properties.State}");

Scaling a capacity based on workload demands:

var capacity = await capacityCollection.GetAsync("prod-fabric-capacity");

var patch = new FabricCapacityPatch
{
    Sku = new FabricSku("F128", FabricSkuTier.Fabric),
    Properties = new FabricCapacityUpdateProperties
    {
        Administration = new FabricCapacityAdministration(
            capacity.Value.Data.Properties.Administration.Members
        )
    }
};

var updateOperation = await capacity.Value.UpdateAsync(
    WaitUntil.Completed,
    patch);

Console.WriteLine($"Scaled to {updateOperation.Value.Data.Sku.Name}");

Implementing cost optimization through automated suspend/resume:

// Suspend during off-hours
var capacity = await capacityCollection.GetAsync("dev-fabric-capacity");
await capacity.Value.SuspendAsync(WaitUntil.Completed);
Console.WriteLine("Capacity suspended - compute billing stopped");

// Resume when needed
var resumeOperation = await capacity.Value.ResumeAsync(WaitUntil.Completed);
Console.WriteLine($"Capacity active: {resumeOperation.Value.Data.Properties.State}");

Best Practices

Always use WaitUntil.Completed for operations that must finish before proceeding with dependent operations. Capacity provisioning, scaling, and state transitions require completion before workspaces can be created or workloads assigned.

Suspend capacities when not actively used, especially for development and testing environments. Fabric capacities bill for compute even when idle, and suspending eliminates these costs while preserving all configurations and workspaces.

Start with smaller SKUs for development (F2, F4, F8) and scale up as needed. Each capacity unit costs money, and development workloads rarely need production-scale resources. Monitor utilization metrics through Azure Monitor before scaling up.

Check name availability before attempting capacity creation in automated workflows. Since names are globally unique, conflicts are common. Implement retry logic with alternative names or timestamp-based suffixes for programmatic provisioning.

Store capacity administrator lists in configuration rather than hardcoding. Administrator requirements change as teams evolve, and externalizing this configuration enables updates without code changes.

Tag resources consistently for cost allocation and organization. Include environment, cost center, team ownership, and automation source tags. These enable filtering in Azure Cost Management and programmatic resource queries.

Handle provisioning states appropriately. Check the ProvisioningState property before performing operations on newly created capacities. Wait for Succeeded state before attempting workspace creation or workload assignments.

When to Use This Skill

Use this skill when building analytics platform automation that provisions Fabric infrastructure alongside data pipelines and reports. Teams deploying unified analytics solutions should manage capacity resources programmatically to ensure consistent configurations across environments.

It's ideal for implementing auto-scaling based on workload demands. Monitor capacity utilization metrics through Azure Monitor, and programmatically scale up during peak periods or scale down during off-hours to optimize costs while maintaining performance.

The skill is valuable for multi-tenant analytics platforms where each tenant receives dedicated capacity. Programmatically create capacity resources per tenant with appropriate SKUs based on their service tier, ensuring isolation and predictable billing.

Use it for implementing cost optimization policies like automatic suspension of idle capacities. Identify capacities with low utilization, suspend them during configured idle periods, and resume when workload activity resumes.

When Not to Use This Skill

Don't use this skill for managing Fabric workspaces, lakehouses, warehouses, notebooks, or data items. Those are data plane operations handled through the Microsoft Fabric REST API or data plane SDKs after capacity provisioning.

If you're deploying capacity infrastructure using ARM templates, Bicep, or Terraform, you don't need this SDK for resource creation. Those tools provide declarative resource definitions often simpler for pure infrastructure provisioning.

Avoid it for querying analytics data or running notebooks. This SDK manages the compute capacity, not the analytics workloads running on that capacity. Use Fabric APIs and tools for data operations.

Don't use it for one-time capacity creation through the Azure portal. The SDK adds value for automated, repeatable provisioning workflows and dynamic scaling based on utilization, not single manual operations.

Related Skills

• azure-mgmt-fabric-py - Manage Fabric capacities using Python
• azure-monitor-query-py - Query capacity utilization metrics for auto-scaling decisions
• azure-resource-manager-cosmosdb-dotnet - Manage Cosmos DB resources for Fabric data storage

Source

This skill is provided by Microsoft as part of the Azure SDK for .NET. Learn more at the NuGet package page, explore the GitHub source code, and review the Microsoft Fabric documentation for comprehensive platform guidance.