Azure Mgmt Fabric Py

MicrosoftOfficialCreated by Microsoft

Skill
Tool integration
Cloud and DevOps
MIT
Low risk

From the author

Azure Fabric Management SDK for Python. Use for managing Microsoft Fabric capacities and resources. Triggers: "azure-mgmt-fabric", "FabricMgmtClient", "Fabric capacity", "Microsoft Fabric", "Power BI capacity".

— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Azure Fabric Management SDK for Python provides a programmatic interface for interacting with Microsoft Fabric capacities. It enables developers to automate the lifecycle management of Fabric resources, including creation, updates, suspension, resumption, and deletion. The SDK supports both synchronous and asynchronous operations, integrates with Azure identity services for secure authentication, and provides mechanisms for handling long-running operations.

What it does

Create and configure Microsoft Fabric capacities
Retrieve details and status of existing capacities
Scale capacity SKUs up or down
Suspend and resume capacities to manage billing
Check availability of capacity names
List available SKUs and capacities within subscriptions or resource groups

When to use it

When automating infrastructure provisioning for Microsoft Fabric
When building custom tools to monitor or manage Fabric capacity states
When implementing cost-optimization workflows by suspending unused capacities
When integrating Fabric resource management into existing CI/CD pipelines

Advantages

Enables programmatic control over Fabric resources
Supports secure authentication via DefaultAzureCredential
Provides structured handling for long-running operations
Facilitates cost management through automated suspension and scaling

Usage examples

“How do I create a new Microsoft Fabric capacity using Python?”: The agent provides a code snippet using FabricMgmtClient and FabricCapacity to define the location, SKU, and administration settings, followed by calling begin_create_or_update().
“Show me how to pause a Fabric capacity to save costs.”: The agent demonstrates using the begin_suspend() method on the fabric_capacities client to transition the capacity to a paused state.
“How can I list all Fabric capacities in my subscription?”: The agent provides a code example using the list_by_subscription() method to iterate through and print all available capacities.
“How do I scale up my Fabric capacity?”: The agent shows how to use the begin_update() method with a new CapacitySku definition to modify the existing capacity.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/microsoft/azure-mgmt-fabric-py/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip azure-mgmt-fabric-py.zip -d .agents/skills

Documentation by Microsoft

Azure Fabric Management SDK for Python

Manage Microsoft Fabric capacities and resources programmatically.

Installation

pip install azure-mgmt-fabric
pip install azure-identity

Environment Variables

AZURE_SUBSCRIPTION_ID=<your-subscription-id>  # Required for all auth methods
AZURE_RESOURCE_GROUP=<your-resource-group>  # Required for all auth methods
AZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production

Authentication & Lifecycle

🔑 Two rules apply to every code sample below:
Prefer DefaultAzureCredential. It works locally (Azure CLI / VS Code / Developer CLI) and in Azure (managed identity, workload identity) with no code change. Avoid connection strings, account/API keys — they bypass Entra audit and rotation.
Local dev: DefaultAzureCredential works as-is.
Production: set AZURE_TOKEN_CREDENTIALS=prod (or AZURE_TOKEN_CREDENTIALS=<specific_credential>) to constrain the credential chain to production-safe credentials.
Wrap every client in a context manager so HTTP transports, sockets, and token caches are released deterministically:
Sync: with <Client>(...) as client:
Async: async with <Client>(...) as client: and async with DefaultAzureCredential() as credential: (from azure.identity.aio)
Snippets may abbreviate this setup, but production code should always follow both rules.

from azure.identity import DefaultAzureCredential, ManagedIdentityCredential
from azure.mgmt.fabric import FabricMgmtClient
import os

# Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>
credential = DefaultAzureCredential(require_envvar=True)
# Or use a specific credential directly in production:
# See https://learn.microsoft.com/python/api/overview/azure/identity-readme?view=azure-python#credential-classes
# credential = ManagedIdentityCredential()

with FabricMgmtClient(
    credential=credential,
    subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"]
) as client:
    # Use `client` for all subsequent operations (see examples below)
    ...

Create Fabric Capacity

from azure.mgmt.fabric import FabricMgmtClient
from azure.mgmt.fabric.models import FabricCapacity, FabricCapacityProperties, CapacitySku
from azure.identity import DefaultAzureCredential
import os

resource_group = os.environ["AZURE_RESOURCE_GROUP"]
capacity_name = "myfabriccapacity"

credential = DefaultAzureCredential()
with FabricMgmtClient(
    credential=credential,
    subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"]
) as client:
    capacity = client.fabric_capacities.begin_create_or_update(
        resource_group_name=resource_group,
        capacity_name=capacity_name,
        resource=FabricCapacity(
            location="eastus",
            sku=CapacitySku(
                name="F2",  # Fabric SKU
                tier="Fabric"
            ),
            properties=FabricCapacityProperties(
                administration=FabricCapacityAdministration(
                    members=["[email protected]"]
                )
            )
        )
    ).result()

print(f"Capacity created: {capacity.name}")

Get Capacity Details

capacity = client.fabric_capacities.get(
    resource_group_name=resource_group,
    capacity_name=capacity_name
)

print(f"Capacity: {capacity.name}")
print(f"SKU: {capacity.sku.name}")
print(f"State: {capacity.properties.state}")
print(f"Location: {capacity.location}")

List Capacities in Resource Group

capacities = client.fabric_capacities.list_by_resource_group(
    resource_group_name=resource_group
)

for capacity in capacities:
    print(f"Capacity: {capacity.name} - SKU: {capacity.sku.name}")

List All Capacities in Subscription

all_capacities = client.fabric_capacities.list_by_subscription()

for capacity in all_capacities:
    print(f"Capacity: {capacity.name} in {capacity.location}")

Update Capacity

from azure.mgmt.fabric.models import FabricCapacityUpdate, CapacitySku

updated = client.fabric_capacities.begin_update(
    resource_group_name=resource_group,
    capacity_name=capacity_name,
    properties=FabricCapacityUpdate(
        sku=CapacitySku(
            name="F4",  # Scale up
            tier="Fabric"
        ),
        tags={"environment": "production"}
    )
).result()

print(f"Updated SKU: {updated.sku.name}")

Suspend Capacity

Pause capacity to stop billing:

client.fabric_capacities.begin_suspend(
    resource_group_name=resource_group,
    capacity_name=capacity_name
).result()

print("Capacity suspended")

Resume Capacity

Resume a paused capacity:

client.fabric_capacities.begin_resume(
    resource_group_name=resource_group,
    capacity_name=capacity_name
).result()

print("Capacity resumed")

Delete Capacity

client.fabric_capacities.begin_delete(
    resource_group_name=resource_group,
    capacity_name=capacity_name
).result()

print("Capacity deleted")

Check Name Availability

from azure.mgmt.fabric.models import CheckNameAvailabilityRequest

result = client.fabric_capacities.check_name_availability(
    location="eastus",
    body=CheckNameAvailabilityRequest(
        name="my-new-capacity",
        type="Microsoft.Fabric/capacities"
    )
)

if result.name_available:
    print("Name is available")
else:
    print(f"Name not available: {result.reason}")

List Available SKUs

skus = client.fabric_capacities.list_skus(
    resource_group_name=resource_group,
    capacity_name=capacity_name
)

for sku in skus:
    print(f"SKU: {sku.name} - Tier: {sku.tier}")

Client Operations

Operation	Method
`client.fabric_capacities`	Capacity CRUD operations
`client.operations`	List available operations

Fabric SKUs

SKU	Description	CUs
`F2`	Entry level	2 Capacity Units
`F4`	Small	4 Capacity Units
`F8`	Medium	8 Capacity Units
`F16`	Large	16 Capacity Units
`F32`	X-Large	32 Capacity Units
`F64`	2X-Large	64 Capacity Units
`F128`	4X-Large	128 Capacity Units
`F256`	8X-Large	256 Capacity Units
`F512`	16X-Large	512 Capacity Units
`F1024`	32X-Large	1024 Capacity Units
`F2048`	64X-Large	2048 Capacity Units

Capacity States

State	Description
`Active`	Capacity is running
`Paused`	Capacity is suspended (no billing)
`Provisioning`	Being created
`Updating`	Being modified
`Deleting`	Being removed
`Failed`	Operation failed

Long-Running Operations

All mutating operations are long-running (LRO). Use .result() to wait:

# Synchronous wait
capacity = client.fabric_capacities.begin_create_or_update(...).result()

# Or poll manually
poller = client.fabric_capacities.begin_create_or_update(...)
while not poller.done():
    print(f"Status: {poller.status()}")
    time.sleep(5)
capacity = poller.result()

Best Practices

Pick sync OR async and stay consistent. Do not mix azure.xxx sync clients with azure.xxx.aio async clients in the same call path. Choose one mode per module.
Always use context managers for clients and async credentials. Wrap every client in with Client(...) as client: (sync) or async with Client(...) as client: (async). For async DefaultAzureCredential from azure.identity.aio, also use async with credential: so tokens and transports are cleaned up.
Use DefaultAzureCredential for code that runs locally. Use a specific token credential for code that runs in Azure.
Suspend unused capacities to reduce costs
Start with smaller SKUs and scale up as needed
Use tags for cost tracking and organization
Check name availability before creating capacities
Handle LRO properly — don't assume immediate completion
Set up capacity admins — specify users who can manage workspaces
Monitor capacity usage via Azure Monitor metrics

Reference Files

File	Contents
references/capabilities.md	Additional non-hero capabilities, operation-group coverage, and production checklists.
references/non-hero-scenarios.md	Dedicated non-hero examples for secondary/advanced scenarios.

Files

ATTRIBUTION.mdAdded by AutoGineer971 B
LICENSELicence file added by AutoGineer1.1 KiB
SKILL.md8.7 KiB
references/capabilities.md2.5 KiB
references/non-hero-scenarios.md3.3 KiB

ATTRIBUTION.md

Attribution

This folder is an unmodified copy of the Agent Skill "azure-mgmt-fabric-py", distributed by AutoGineer (https://autogineer.com/agent-skills).

Source: https://github.com/microsoft/skills/tree/0696600436a9669184ce47e8d8b2ceac62e4bfac/.github/plugins/azure-sdk-python/skills/azure-mgmt-fabric-py
Commit: 0696600436a9669184ce47e8d8b2ceac62e4bfac
Created by: Microsoft (https://github.com/microsoft/skills/tree/0696600436a9669184ce47e8d8b2ceac62e4bfac/.github/plugins/azure-sdk-python/skills/azure-mgmt-fabric-py)
Publisher: Microsoft (https://github.com/microsoft)
Licence: MIT License (https://spdx.org/licenses/MIT.html)
Licence evidence: declared in the frontmatter ("license: MIT")
Retrieved: 2026-11-07

The skill's own files are unmodified copies. AutoGineer is not affiliated with or endorsed by the author or the publisher.

Files added by AutoGineer

ATTRIBUTION.md: this file, written by AutoGineer
LICENSE: copied from LICENSE

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an API key, Needs Python

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Microsoft

Publisher

Microsoft (Official)

Source

microsoft/skills · .github/plugins/azure-sdk-python/skills/azure-mgmt-fabric-py · commit 0696600

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download azure-mgmt-fabric-py.zip