Azure Mgmt Fabric Dotnet

1---
2name: azure-mgmt-fabric-dotnet
3description: |
4  Azure Resource Manager SDK for Fabric in .NET. Use for MANAGEMENT PLANE operations: provisioning, scaling, suspending/resuming Microsoft Fabric capacities, checking name availability, and listing SKUs via Azure Resource Manager. Triggers: "Fabric capacity", "create capacity", "suspend capacity", "resume capacity", "Fabric SKU", "provision Fabric", "ARM Fabric", "FabricCapacityResource".
5package: Azure.ResourceManager.Fabric
6---
7 
8# Azure.ResourceManager.Fabric (.NET)
9 
10Management plane SDK for provisioning and managing Microsoft Fabric capacity resources via Azure Resource Manager.
11 
12> **Management Plane Only**
13> This SDK manages Fabric *capacities* (compute resources). For working with Fabric workspaces, lakehouses, warehouses, and data items, use the Microsoft Fabric REST API or data plane SDKs.
14 
15## Installation
16 
17```bash
18dotnet add package Azure.ResourceManager.Fabric
19dotnet add package Azure.Identity
20```
21 
22**Current Version**: 1.0.0 (GA - September 2025)  
23**API Version**: 2023-11-01  
24**Target Frameworks**: .NET 8.0, .NET Standard 2.0
25 
26## Environment Variables
27 
28```bash
29AZURE_SUBSCRIPTION_ID=<your-subscription-id>
30# For service principal auth (optional)
31AZURE_TENANT_ID=<tenant-id>
32AZURE_CLIENT_ID=<client-id>
33AZURE_CLIENT_SECRET=<client-secret>
34```
35 
36## Authentication
37 
38```csharp
39using Azure.Identity;
40using Azure.ResourceManager;
41using Azure.ResourceManager.Fabric;
42 
43// Always use DefaultAzureCredential
44var credential = new DefaultAzureCredential();
45var armClient = new ArmClient(credential);
46 
47// Get subscription
48var subscription = await armClient.GetDefaultSubscriptionAsync();
49```
50 
51## Resource Hierarchy
52 
53```
54ArmClient
55└── SubscriptionResource
56    └── ResourceGroupResource
57        └── FabricCapacityResource
58```
59 
60## Core Workflows
61 
62### 1. Create Fabric Capacity
63 
64```csharp
65using Azure.ResourceManager.Fabric;
66using Azure.ResourceManager.Fabric.Models;
67using Azure.Core;
68 
69// Get resource group
70var resourceGroup = await subscription.GetResourceGroupAsync("my-resource-group");
71 
72// Define capacity configuration
73var administration = new FabricCapacityAdministration(
74    new[] { "admin@contoso.com" }  // Capacity administrators (UPNs or object IDs)
75);
76 
77var properties = new FabricCapacityProperties(administration);
78 
79var sku = new FabricSku("F64", FabricSkuTier.Fabric);
80 
81var capacityData = new FabricCapacityData(
82    AzureLocation.WestUS2,
83    properties,
84    sku)
85{
86    Tags = { ["Environment"] = "Production" }
87};
88 
89// Create capacity (long-running operation)
90var capacityCollection = resourceGroup.Value.GetFabricCapacities();
91var operation = await capacityCollection.CreateOrUpdateAsync(
92    WaitUntil.Completed,
93    "my-fabric-capacity",
94    capacityData);
95 
96FabricCapacityResource capacity = operation.Value;
97Console.WriteLine($"Created capacity: {capacity.Data.Name}");
98Console.WriteLine($"State: {capacity.Data.Properties.State}");
99```
100 
101### 2. Get Fabric Capacity
102 
103```csharp
104// Get existing capacity
105var capacity = await resourceGroup.Value
106    .GetFabricCapacityAsync("my-fabric-capacity");
107 
108Console.WriteLine($"Name: {capacity.Value.Data.Name}");
109Console.WriteLine($"Location: {capacity.Value.Data.Location}");
110Console.WriteLine($"SKU: {capacity.Value.Data.Sku.Name}");
111Console.WriteLine($"State: {capacity.Value.Data.Properties.State}");
112Console.WriteLine($"Provisioning State: {capacity.Value.Data.Properties.ProvisioningState}");
113```
114 
115### 3. Update Capacity (Scale SKU or Change Admins)
116 
117```csharp
118var capacity = await resourceGroup.Value
119    .GetFabricCapacityAsync("my-fabric-capacity");
120 
121var patch = new FabricCapacityPatch
122{
123    Sku = new FabricSku("F128", FabricSkuTier.Fabric),  // Scale up
124    Properties = new FabricCapacityUpdateProperties
125    {
126        Administration = new FabricCapacityAdministration(
127            new[] { "admin@contoso.com", "newadmin@contoso.com" }
128        )
129    }
130};
131 
132var updateOperation = await capacity.Value.UpdateAsync(
133    WaitUntil.Completed,
134    patch);
135 
136Console.WriteLine($"Updated SKU: {updateOperation.Value.Data.Sku.Name}");
137```
138 
139### 4. Suspend and Resume Capacity
140 
141```csharp
142// Suspend capacity (stop billing for compute)
143await capacity.Value.SuspendAsync(WaitUntil.Completed);
144Console.WriteLine("Capacity suspended");
145 
146// Resume capacity
147var resumeOperation = await capacity.Value.ResumeAsync(WaitUntil.Completed);
148Console.WriteLine($"Capacity resumed. State: {resumeOperation.Value.Data.Properties.State}");
149```
150 
151### 5. Delete Capacity
152 
153```csharp
154await capacity.Value.DeleteAsync(WaitUntil.Completed);
155Console.WriteLine("Capacity deleted");
156```
157 
158### 6. List All Capacities
159 
160```csharp
161// In a resource group
162await foreach (var cap in resourceGroup.Value.GetFabricCapacities())
163{
164    Console.WriteLine($"- {cap.Data.Name} ({cap.Data.Sku.Name})");
165}
166 
167// In a subscription
168await foreach (var cap in subscription.GetFabricCapacitiesAsync())
169{
170    Console.WriteLine($"- {cap.Data.Name} in {cap.Data.Location}");
171}
172```
173 
174### 7. Check Name Availability
175 
176```csharp
177var checkContent = new FabricNameAvailabilityContent
178{
179    Name = "my-new-capacity",
180    ResourceType = "Microsoft.Fabric/capacities"
181};
182 
183var result = await subscription.CheckFabricCapacityNameAvailabilityAsync(
184    AzureLocation.WestUS2,
185    checkContent);
186 
187if (result.Value.IsNameAvailable == true)
188{
189    Console.WriteLine("Name is available!");
190}
191else
192{
193    Console.WriteLine($"Name unavailable: {result.Value.Reason} - {result.Value.Message}");
194}
195```
196 
197### 8. List Available SKUs
198 
199```csharp
200// List all SKUs available in subscription
201await foreach (var skuDetails in subscription.GetSkusFabricCapacitiesAsync())
202{
203    Console.WriteLine($"SKU: {skuDetails.Name}");
204    Console.WriteLine($"  Resource Type: {skuDetails.ResourceType}");
205    foreach (var location in skuDetails.Locations)
206    {
207        Console.WriteLine($"  Location: {location}");
208    }
209}
210 
211// List SKUs available for an existing capacity (for scaling)
212await foreach (var skuDetails in capacity.Value.GetSkusForCapacityAsync())
213{
214    Console.WriteLine($"Can scale to: {skuDetails.Sku.Name}");
215}
216```
217 
218## SKU Reference
219 
220| SKU Name | Capacity Units (CU) | Power BI Equivalent |
221|----------|---------------------|---------------------|
222| F2 | 2 | - |
223| F4 | 4 | - |
224| F8 | 8 | EM1/A1 |
225| F16 | 16 | EM2/A2 |
226| F32 | 32 | EM3/A3 |
227| F64 | 64 | P1/A4 |
228| F128 | 128 | P2/A5 |
229| F256 | 256 | P3/A6 |
230| F512 | 512 | P4/A7 |
231| F1024 | 1024 | P5/A8 |
232| F2048 | 2048 | - |
233 
234## Key Types Reference
235 
236| Type | Purpose |
237|------|---------|
238| `ArmClient` | Entry point for all ARM operations |
239| `FabricCapacityResource` | Represents a Fabric capacity instance |
240| `FabricCapacityCollection` | Collection for capacity CRUD operations |
241| `FabricCapacityData` | Capacity creation/read data model |
242| `FabricCapacityPatch` | Capacity update payload |
243| `FabricCapacityProperties` | Capacity properties (administration, state) |
244| `FabricCapacityAdministration` | Admin members configuration |
245| `FabricSku` | SKU configuration (name and tier) |
246| `FabricSkuTier` | Pricing tier (currently only "Fabric") |
247| `FabricProvisioningState` | Provisioning states (Succeeded, Failed, etc.) |
248| `FabricResourceState` | Resource states (Active, Suspended, etc.) |
249| `FabricNameAvailabilityContent` | Name availability check request |
250| `FabricNameAvailabilityResult` | Name availability check response |
251 
252## Provisioning and Resource States
253 
254### Provisioning States (`FabricProvisioningState`)
255- `Succeeded` - Operation completed successfully
256- `Failed` - Operation failed
257- `Canceled` - Operation was canceled
258- `Deleting` - Capacity is being deleted
259- `Provisioning` - Initial provisioning in progress
260- `Updating` - Update operation in progress
261 
262### Resource States (`FabricResourceState`)
263- `Active` - Capacity is running and available
264- `Provisioning` - Being provisioned
265- `Failed` - In failed state
266- `Updating` - Being updated
267- `Deleting` - Being deleted
268- `Suspending` - Transitioning to suspended
269- `Suspended` - Suspended (not billing for compute)
270- `Pausing` - Transitioning to paused
271- `Paused` - Paused
272- `Resuming` - Resuming from suspended/paused
273- `Scaling` - Scaling to different SKU
274- `Preparing` - Preparing resources
275 
276## Best Practices
277 
2781. **Use `WaitUntil.Completed`** for operations that must finish before proceeding
2792. **Use `WaitUntil.Started`** when you want to poll manually or run operations in parallel
2803. **Always use `DefaultAzureCredential`** — never hardcode credentials
2814. **Handle `RequestFailedException`** for ARM API errors
2825. **Use `CreateOrUpdateAsync`** for idempotent operations
2836. **Suspend when not in use** — Fabric capacities bill for compute even when idle
2847. **Check provisioning state** before performing operations on a capacity
2858. **Use appropriate SKU** — Start small (F2/F4) for dev/test, scale up for production
286 
287## Error Handling
288 
289```csharp
290using Azure;
291 
292try
293{
294    var operation = await capacityCollection.CreateOrUpdateAsync(
295        WaitUntil.Completed, capacityName, capacityData);
296}
297catch (RequestFailedException ex) when (ex.Status == 409)
298{
299    Console.WriteLine("Capacity already exists or conflict");
300}
301catch (RequestFailedException ex) when (ex.Status == 400)
302{
303    Console.WriteLine($"Invalid configuration: {ex.Message}");
304}
305catch (RequestFailedException ex) when (ex.Status == 403)
306{
307    Console.WriteLine("Insufficient permissions or quota exceeded");
308}
309catch (RequestFailedException ex)
310{
311    Console.WriteLine($"ARM Error: {ex.Status} - {ex.ErrorCode}: {ex.Message}");
312}
313```
314 
315## Common Pitfalls
316 
3171. **Capacity names must be globally unique** — Fabric capacity names must be unique across all Azure subscriptions
3182. **Suspend doesn't delete** — Suspended capacities still exist but don't bill for compute
3193. **SKU changes may require downtime** — Scaling operations can take several minutes
3204. **Admin UPNs must be valid** — Capacity administrators must be valid Azure AD users
3215. **Location constraints** — Not all SKUs are available in all regions; use `GetSkusFabricCapacitiesAsync` to check
3226. **Long provisioning times** — Capacity creation can take 5-15 minutes
323 
324## Related SDKs
325 
326| SDK | Purpose | Install |
327|-----|---------|---------|
328| `Azure.ResourceManager.Fabric` | Management plane (this SDK) | `dotnet add package Azure.ResourceManager.Fabric` |
329| `Microsoft.Fabric.Api` | Data plane operations (beta) | `dotnet add package Microsoft.Fabric.Api --prerelease` |
330| `Azure.ResourceManager` | Core ARM SDK | `dotnet add package Azure.ResourceManager` |
331| `Azure.Identity` | Authentication | `dotnet add package Azure.Identity` |
332 
333## References
334 
335- [Azure.ResourceManager.Fabric NuGet](https://www.nuget.org/packages/Azure.ResourceManager.Fabric)
336- [GitHub Source](https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/fabric/Azure.ResourceManager.Fabric)
337- [Microsoft Fabric Documentation](https://learn.microsoft.com/fabric/)
338- [Fabric Capacity Management](https://learn.microsoft.com/fabric/admin/service-admin-portal-capacity-settings)
339