0
# Azure Subscription Management Client Library
1

2
A comprehensive Python client library for managing Azure subscriptions through the Azure Resource Manager API. This package enables developers to programmatically create, modify, and manage Azure subscriptions, tenant operations, and billing account interactions.
3

4
## Package Information
5

6
- **Package Name**: azure-mgmt-subscription
7
- **Package Type**: Azure Management SDK
8
- **Language**: Python
9
- **Installation**: `pip install azure-mgmt-subscription`
10

11
## Core Imports
12

13
```python
14
from azure.mgmt.subscription import SubscriptionClient
15
```
16

17
For asynchronous operations:
18

19
```python
20
from azure.mgmt.subscription.aio import SubscriptionClient
21
```
22

23
Import specific models and enums as needed:
24

25
```python
26
from azure.mgmt.subscription.models import (
27
    Subscription,
28
    SubscriptionName,
29
    AcceptOwnershipRequest,
30
    PutAliasRequest,
31
    SubscriptionState,
32
    Workload
33
)
34
```
35

36
## Basic Usage
37

38
```python
39
from azure.identity import DefaultAzureCredential
40
from azure.mgmt.subscription import SubscriptionClient
41

42
# Create credential and client
43
credential = DefaultAzureCredential()
44
client = SubscriptionClient(credential)
45

46
# List all accessible subscriptions
47
subscriptions = list(client.subscriptions.list())
48
for subscription in subscriptions:
49
    print(f"Subscription: {subscription.display_name} ({subscription.subscription_id})")
50

51
# Get details about a specific subscription
52
subscription_id = "your-subscription-id"
53
subscription = client.subscriptions.get(subscription_id)
54
print(f"State: {subscription.state}")
55
print(f"Location: {subscription.subscription_policies.location_placement_id}")
56

57
# List available regions for a subscription
58
locations = list(client.subscriptions.list_locations(subscription_id))
59
for location in locations:
60
    print(f"Region: {location.name} - {location.display_name}")
61

62
# Always close the client when done
63
client.close()
64
```
65

66
## Architecture
67

68
The azure-mgmt-subscription client provides access to seven distinct operations groups, each handling specific aspects of Azure subscription management:
69

70
- **SubscriptionClient**: Main client class providing access to all operations
71
- **Operations Groups**: Specialized handlers for subscriptions, tenants, aliases, policies, and billing
72
- **Models**: Rich data structures representing Azure subscription resources
73
- **Authentication**: Integration with Azure Identity for secure API access
74
- **Async Support**: Complete async/await support for non-blocking operations
75

76
## Capabilities
77

78
### Subscription Management
79

80
Core subscription operations including listing, retrieving details, and managing subscription lifecycle (cancel, rename, enable). These operations form the foundation of subscription management workflows.
81

82
```python { .api }
83
# List all subscriptions
84
def list(**kwargs) -> Iterable[Subscription]: ...
85

86
# Get subscription details
87
def get(subscription_id: str, **kwargs) -> Subscription: ...
88

89
# List available locations for a subscription
90
def list_locations(subscription_id: str, **kwargs) -> Iterable[Location]: ...
91
```
92

93
[Subscription Management](./subscription-management.md)
94

95
### Tenant Operations
96

97
Tenant discovery and management operations that allow applications to identify and work with Azure Active Directory tenants accessible to the authenticated user.
98

99
```python { .api }
100
# List accessible tenants
101
def list(**kwargs) -> Iterable[TenantIdDescription]: ...
102
```
103

104
[Tenant Operations](./tenant-operations.md)
105

106
### Subscription Lifecycle
107

108
Individual subscription lifecycle management including cancellation, renaming, enabling, and ownership transfer operations with support for long-running operations.
109

110
```python { .api }
111
# Cancel a subscription
112
def cancel(subscription_id: str, **kwargs) -> CanceledSubscriptionId: ...
113

114
# Rename a subscription
115
def rename(subscription_id: str, body: Union[SubscriptionName, IO], **kwargs) -> RenamedSubscriptionId: ...
116

117
# Enable a disabled subscription
118
def enable(subscription_id: str, **kwargs) -> EnabledSubscriptionId: ...
119

120
# Accept ownership transfer (Long Running Operation)
121
def begin_accept_ownership(subscription_id: str, body: Union[AcceptOwnershipRequest, IO], **kwargs) -> LROPoller[None]: ...
122
```
123

124
[Subscription Lifecycle](./subscription-lifecycle.md)
125

126
### Subscription Creation via Aliases
127

128
Subscription creation and alias management operations that enable programmatic subscription provisioning through Azure's alias system with long-running operation support.
129

130
```python { .api }
131
# Create subscription via alias (Long Running Operation)
132
def begin_create(alias_name: str, body: Union[PutAliasRequest, IO], **kwargs) -> LROPoller[SubscriptionAliasResponse]: ...
133

134
# Get alias information
135
def get(alias_name: str, **kwargs) -> SubscriptionAliasResponse: ...
136

137
# Delete an alias
138
def delete(alias_name: str, **kwargs) -> None: ...
139

140
# List all aliases
141
def list(**kwargs) -> SubscriptionAliasListResult: ...
142
```
143

144
[Subscription Creation](./subscription-creation.md)
145

146
### Policy Management
147

148
Subscription policy management at tenant and billing account levels, including policy creation, updates, and retrieval for governance and compliance scenarios.
149

150
```python { .api }
151
# Add or update tenant policy
152
def add_update_policy_for_tenant(body: Union[PutTenantPolicyRequestProperties, IO], **kwargs) -> GetTenantPolicyResponse: ...
153

154
# Get tenant policy
155
def get_policy_for_tenant(**kwargs) -> GetTenantPolicyResponse: ...
156

157
# Get billing account policy
158
def get_policy(billing_account_id: str, **kwargs) -> BillingAccountPoliciesResponse: ...
159
```
160

161
[Policy Management](./policy-management.md)
162

163
### Service Operations
164

165
Service metadata and discovery operations that provide information about available API operations and service capabilities.
166

167
```python { .api }
168
# List available API operations
169
def list(**kwargs) -> Iterable[Operation]: ...
170
```
171

172
[Service Operations](./service-operations.md)
173

174
## Error Handling
175

176
All operations can raise Azure-specific exceptions with structured error information:
177

178
```python
179
from azure.core.exceptions import HttpResponseError
180

181
try:
182
    subscription = client.subscriptions.get("invalid-subscription-id")
183
except HttpResponseError as e:
184
    print(f"Error: {e.status_code} - {e.message}")
185
```
186

187
## Authentication
188

189
The client requires Azure credentials for authentication. Use Azure Identity library for best practices:
190

191
```python
192
from azure.identity import DefaultAzureCredential, ClientSecretCredential
193

194
# Recommended: Use DefaultAzureCredential
195
credential = DefaultAzureCredential()
196

197
# Or use specific credential types
198
credential = ClientSecretCredential(
199
    tenant_id="your-tenant-id",
200
    client_id="your-client-id",
201
    client_secret="your-client-secret"
202
)
203

204
client = SubscriptionClient(credential)
205
```
206

207
## Async Support
208

209
Complete async support is available for non-blocking operations:
210

211
```python
212
import asyncio
213
from azure.identity.aio import DefaultAzureCredential
214
from azure.mgmt.subscription.aio import SubscriptionClient
215

216
async def list_subscriptions():
217
    credential = DefaultAzureCredential()
218
    async with SubscriptionClient(credential) as client:
219
        subscriptions = []
220
        async for subscription in client.subscriptions.list():
221
            subscriptions.append(subscription)
222
        return subscriptions
223

224
# Run async operation
225
subscriptions = asyncio.run(list_subscriptions())
226
```
227

228
## Core Types
229

230
```python { .api }
231
class SubscriptionClient:
232
    """The main subscription client."""
233
    def __init__(self, credential: TokenCredential, base_url: str = "https://management.azure.com", **kwargs): ...
234
    def close(self) -> None: ...
235
    def __enter__(self): ...
236
    def __exit__(self, *exc_details): ...
237

238
class Subscription:
239
    """Azure subscription information."""
240
    id: str  # The fully qualified ID for the subscription
241
    subscription_id: str  # The subscription ID
242
    display_name: str  # The subscription display name
243
    state: Union[str, SubscriptionState]  # Current subscription state
244
    subscription_policies: SubscriptionPolicies  # Associated policies
245
    authorization_source: str  # Authorization method used
246

247
class Location:
248
    """Azure geographic location."""
249
    id: str  # The fully qualified ID of the location
250
    subscription_id: str  # The subscription ID
251
    name: str  # The location name
252
    display_name: str  # The display name of the location
253
    latitude: str  # The latitude of the location
254
    longitude: str  # The longitude of the location
255

256
class TenantIdDescription:
257
    """Azure Active Directory tenant information."""
258
    id: str
259
    tenant_id: str
260
    tenant_category: str
261
    display_name: str
262
    default_domain: str
263
```