0
# Subscription Creation via Aliases
1

2
Subscription creation and alias management operations that enable programmatic subscription provisioning through Azure's alias system. These operations support enterprise-scale subscription creation workflows with long-running operation support and comprehensive alias management.
3

4
## Capabilities
5

6
### Create Subscription via Alias (Long Running Operation)
7

8
Creates a new Azure subscription using an alias. This is a long-running operation that provisions a subscription with specified billing and configuration settings.
9

10
```python { .api }
11
def begin_create(alias_name: str, body: Union[PutAliasRequest, IO], **kwargs) -> LROPoller[SubscriptionAliasResponse]:
12
    """
13
    Create Alias Subscription (Long Running Operation).
14
    
15
    Args:
16
        alias_name (str): The alias name for the subscription
17
        body (PutAliasRequest): Alias creation request with subscription details
18
        
19
    Returns:
20
        LROPoller[SubscriptionAliasResponse]: Long-running operation poller yielding alias response
21
    """
22
```
23

24
**Usage Example:**
25

26
```python
27
from azure.identity import DefaultAzureCredential
28
from azure.mgmt.subscription import SubscriptionClient
29
from azure.mgmt.subscription.models import (
30
    PutAliasRequest,
31
    PutAliasRequestProperties,
32
    PutAliasRequestAdditionalProperties,
33
    Workload
34
)
35

36
credential = DefaultAzureCredential()
37
client = SubscriptionClient(credential)
38

39
alias_name = "my-subscription-alias"
40

41
# Create alias properties
42
additional_properties = PutAliasRequestAdditionalProperties(
43
    management_group_id="/providers/Microsoft.Management/managementGroups/my-mg",
44
    tags={"Environment": "Production", "CostCenter": "12345"}
45
)
46

47
properties = PutAliasRequestProperties(
48
    display_name="My New Enterprise Subscription",
49
    billing_scope="/subscriptions/00000000-0000-0000-0000-000000000000/billingProfiles/ABCD-EFGH-12345678",
50
    workload=Workload.PRODUCTION,
51
    additional_properties=additional_properties
52
)
53

54
alias_request = PutAliasRequest(properties=properties)
55

56
try:
57
    # Start the long-running operation
58
    poller = client.alias.begin_create(alias_name, alias_request)
59
    print(f"Subscription creation initiated with alias: {alias_name}")
60
    print("Waiting for completion...")
61
    
62
    # Wait for completion (this may take several minutes)
63
    result = poller.result()
64
    
65
    print(f"Subscription created successfully!")
66
    print(f"Alias ID: {result.id}")
67
    print(f"Subscription ID: {result.properties.subscription_id}")
68
    print(f"Provisioning State: {result.properties.provisioning_state}")
69
    
70
except Exception as e:
71
    print(f"Failed to create subscription: {e}")
72
```
73

74
### Get Alias Information
75

76
Retrieves information about a subscription alias, including its current status and associated subscription details.
77

78
```python { .api }
79
def get(alias_name: str, **kwargs) -> SubscriptionAliasResponse:
80
    """
81
    Get Alias Subscription.
82
    
83
    Args:
84
        alias_name (str): The alias name to retrieve
85
        
86
    Returns:
87
        SubscriptionAliasResponse: Alias information and status
88
    """
89
```
90

91
**Usage Example:**
92

93
```python
94
alias_name = "my-subscription-alias"
95

96
try:
97
    alias_info = client.alias.get(alias_name)
98
    
99
    print(f"Alias Name: {alias_info.name}")
100
    print(f"Alias ID: {alias_info.id}")
101
    print(f"Type: {alias_info.type}")
102
    
103
    properties = alias_info.properties
104
    if properties:
105
        print(f"Display Name: {properties.display_name}")
106
        print(f"Subscription ID: {properties.subscription_id}")
107
        print(f"Provisioning State: {properties.provisioning_state}")
108
        print(f"Accept Ownership State: {properties.accept_ownership_state}")
109
        print(f"Billing Scope: {properties.billing_scope}")
110
        print(f"Workload: {properties.workload}")
111
        
112
        if properties.tags:
113
            print("Tags:")
114
            for key, value in properties.tags.items():
115
                print(f"  {key}: {value}")
116
                
117
except Exception as e:
118
    print(f"Failed to get alias information: {e}")
119
```
120

121
### Delete Alias
122

123
Deletes a subscription alias. Note that this does not delete the associated subscription, only the alias reference.
124

125
```python { .api }
126
def delete(alias_name: str, **kwargs) -> None:
127
    """
128
    Delete Alias.
129
    
130
    Args:
131
        alias_name (str): The alias name to delete
132
        
133
    Returns:
134
        None
135
    """
136
```
137

138
**Usage Example:**
139

140
```python
141
alias_name = "my-subscription-alias"
142

143
try:
144
    client.alias.delete(alias_name)
145
    print(f"Successfully deleted alias: {alias_name}")
146
    
147
    # Verify deletion by trying to get the alias
148
    try:
149
        client.alias.get(alias_name)
150
        print("Warning: Alias still exists after deletion")
151
    except Exception:
152
        print("Alias successfully removed")
153
        
154
except Exception as e:
155
    print(f"Failed to delete alias: {e}")
156
```
157

158
### List All Aliases
159

160
Lists all subscription aliases accessible to the authenticated user.
161

162
```python { .api }
163
def list(**kwargs) -> SubscriptionAliasListResult:
164
    """
165
    List Alias Subscription.
166
    
167
    Returns:
168
        SubscriptionAliasListResult: List of all subscription aliases
169
    """
170
```
171

172
**Usage Example:**
173

174
```python
175
try:
176
    aliases_result = client.alias.list()
177
    aliases = aliases_result.value
178
    
179
    print(f"Found {len(aliases)} subscription aliases:")
180
    
181
    for alias in aliases:
182
        print(f"Name: {alias.name}")
183
        print(f"ID: {alias.id}")
184
        
185
        if alias.properties:
186
            print(f"  Display Name: {alias.properties.display_name}")
187
            print(f"  Subscription ID: {alias.properties.subscription_id}")
188
            print(f"  State: {alias.properties.provisioning_state}")
189
        print("---")
190
        
191
except Exception as e:
192
    print(f"Failed to list aliases: {e}")
193
```
194

195
## Advanced Usage Patterns
196

197
### Monitor Subscription Creation Progress
198

199
```python
200
import time
201
from azure.core.exceptions import HttpResponseError
202

203
def monitor_subscription_creation(client, alias_name, poller):
204
    """Monitor subscription creation with periodic status updates."""
205
    while not poller.done():
206
        try:
207
            # Check current alias status
208
            alias_info = client.alias.get(alias_name)
209
            properties = alias_info.properties
210
            
211
            if properties:
212
                print(f"Provisioning State: {properties.provisioning_state}")
213
                print(f"Accept Ownership State: {properties.accept_ownership_state}")
214
                
215
                if properties.subscription_id:
216
                    print(f"Subscription ID: {properties.subscription_id}")
217
            
218
            # Wait before next check
219
            time.sleep(30)
220
            
221
        except HttpResponseError as e:
222
            if e.status_code == 404:
223
                print("Alias no longer found - may have been cleaned up")
224
                break
225
            else:
226
                print(f"Error checking status: {e}")
227
        
228
        except KeyboardInterrupt:
229
            print("Monitoring interrupted. Creation continues in background.")
230
            break
231
    
232
    return poller.done()
233

234
# Usage
235
poller = client.alias.begin_create(alias_name, alias_request)
236
success = monitor_subscription_creation(client, alias_name, poller)
237
if success:
238
    final_result = poller.result()
239
    print(f"Final subscription ID: {final_result.properties.subscription_id}")
240
```
241

242
### Batch Subscription Creation
243

244
```python
245
def create_multiple_subscriptions(client, subscription_configs):
246
    """Create multiple subscriptions concurrently."""
247
    pollers = []
248
    
249
    for config in subscription_configs:
250
        alias_name = config["alias_name"]
251
        alias_request = config["request"]
252
        
253
        try:
254
            poller = client.alias.begin_create(alias_name, alias_request)
255
            pollers.append((alias_name, poller))
256
            print(f"Started creation for: {alias_name}")
257
        except Exception as e:
258
            print(f"Failed to start creation for {alias_name}: {e}")
259
    
260
    # Monitor all creations
261
    completed = []
262
    for alias_name, poller in pollers:
263
        try:
264
            result = poller.result()  # Wait for completion
265
            completed.append({
266
                "alias_name": alias_name,
267
                "subscription_id": result.properties.subscription_id,
268
                "status": "Success"
269
            })
270
        except Exception as e:
271
            completed.append({
272
                "alias_name": alias_name,
273
                "status": f"Failed: {e}"
274
            })
275
    
276
    return completed
277
```
278

279
## Error Handling
280

281
Common errors when working with subscription aliases:
282

283
```python
284
from azure.core.exceptions import HttpResponseError
285

286
def handle_alias_errors(operation_name: str, func, *args, **kwargs):
287
    """Generic error handler for alias operations."""
288
    try:
289
        return func(*args, **kwargs)
290
    except HttpResponseError as e:
291
        if e.status_code == 409:
292
            print(f"{operation_name}: Alias already exists or conflict with existing resource")
293
        elif e.status_code == 400:
294
            print(f"{operation_name}: Bad request - check billing scope and parameters")
295
        elif e.status_code == 403:
296
            print(f"{operation_name}: Insufficient permissions for subscription creation")
297
        elif e.status_code == 404:
298
            print(f"{operation_name}: Alias not found")
299
        else:
300
            print(f"{operation_name}: Error {e.status_code} - {e.message}")
301
        raise
302
    except Exception as e:
303
        print(f"{operation_name}: Unexpected error - {e}")
304
        raise
305
```
306

307
## Types
308

309
```python { .api }
310
class PutAliasRequest:
311
    """Request object for creating subscription alias."""
312
    properties: PutAliasRequestProperties  # Alias creation properties
313

314
class PutAliasRequestProperties:
315
    """Properties for alias creation request."""
316
    display_name: str  # Display name for the subscription (optional)
317
    billing_scope: str  # Billing scope for the subscription (optional)
318
    workload: Union[str, Workload]  # Workload type (optional)
319
    additional_properties: PutAliasRequestAdditionalProperties  # Additional settings (optional)
320

321
class PutAliasRequestAdditionalProperties:
322
    """Additional properties for alias creation."""
323
    management_group_id: str  # Management group to place subscription (optional)
324
    subscription_tenant_id: str  # Tenant ID for subscription (optional)
325
    subscription_owner_id: str  # Owner ID for subscription (optional)
326
    tags: Dict[str, str]  # Tags to apply to subscription (optional)
327

328
class SubscriptionAliasResponse:
329
    """Response from alias operations."""
330
    id: str  # Alias resource ID
331
    name: str  # Alias name
332
    type: str  # Resource type
333
    properties: SubscriptionAliasResponseProperties  # Alias properties
334
    system_data: SystemData  # System metadata
335

336
class SubscriptionAliasResponseProperties:
337
    """Properties of subscription alias response."""
338
    subscription_id: str  # Associated subscription ID
339
    display_name: str  # Display name of subscription
340
    provisioning_state: Union[str, ProvisioningState]  # Current provisioning state
341
    accept_ownership_state: Union[str, AcceptOwnership]  # Current ownership state
342
    billing_scope: str  # Billing scope used
343
    workload: Union[str, Workload]  # Workload type
344
    management_group_id: str  # Management group placement
345
    subscription_owner_id: str  # Subscription owner
346
    tags: Dict[str, str]  # Applied tags
347
    created_time: str  # Creation timestamp
348

349
class SubscriptionAliasListResult:
350
    """Result of listing subscription aliases."""
351
    value: List[SubscriptionAliasResponse]  # List of aliases
352
    next_link: str  # URL for next page of results (optional)
353
```
354

355
## Enums
356

357
```python { .api }
358
class Workload(str, Enum):
359
    """The workload type of the subscription."""
360
    PRODUCTION = "Production"
361
    DEV_TEST = "DevTest"
362

363
class ProvisioningState(str, Enum):
364
    """The provisioning state of the resource."""
365
    ACCEPTED = "Accepted"
366
    SUCCEEDED = "Succeeded"
367
    FAILED = "Failed"
368

369
class AcceptOwnership(str, Enum):
370
    """The accept ownership state of the resource."""
371
    PENDING = "Pending"
372
    COMPLETED = "Completed"
373
    EXPIRED = "Expired"
374
```