0
# Immediate Operations  
1

2
Execute VM operations immediately without scheduling delays, providing direct control over virtual machine lifecycle operations. These operations bypass scheduling and execute as soon as possible.
3

4
## Capabilities
5

6
### Execute Deallocate Operation
7

8
Immediately deallocate virtual machines, releasing compute resources while preserving attached storage and network configurations.
9

10
```python { .api }
11
def virtual_machines_execute_deallocate(
12
    self, 
13
    locationparameter: str, 
14
    request_body: Union[ExecuteDeallocateRequest, JSON, IO[bytes]], 
15
    **kwargs: Any
16
) -> DeallocateResourceOperationResponse:
17
    """
18
    Execute immediate deallocate operation on VMs without scheduling delay.
19
    
20
    Parameters:
21
    - locationparameter: Azure region where operation will be executed (required)
22
    - request_body: Execute deallocate request with execution parameters (required)
23
    
24
    Returns:
25
    Response containing operation ID and status information
26
    """
27
```
28

29
**Usage Example:**
30

31
```python
32
from azure.mgmt.computeschedule.models import (
33
    ExecuteDeallocateRequest,
34
    ExecutionParameters,
35
    Resources
36
)
37

38
# Define VMs to deallocate immediately
39
execution_params = ExecutionParameters(
40
    resources=Resources(
41
        ids=[
42
            "/subscriptions/{subscription_id}/resourceGroups/testRG/providers/Microsoft.Compute/virtualMachines/testVM1",
43
            "/subscriptions/{subscription_id}/resourceGroups/testRG/providers/Microsoft.Compute/virtualMachines/testVM2"
44
        ]
45
    )
46
)
47

48
# Create immediate execution request
49
request = ExecuteDeallocateRequest(
50
    execution_parameters=execution_params
51
)
52

53
# Execute immediately
54
response = client.scheduled_actions.virtual_machines_execute_deallocate(
55
    locationparameter="eastus",
56
    request_body=request
57
)
58

59
print(f"Immediate deallocate operation started with ID: {response.operation_id}")
60
```
61

62
### Execute Hibernate Operation
63

64
Immediately hibernate virtual machines, preserving memory state to disk while stopping compute billing.
65

66
```python { .api }
67
def virtual_machines_execute_hibernate(
68
    self, 
69
    locationparameter: str, 
70
    request_body: Union[ExecuteHibernateRequest, JSON, IO[bytes]], 
71
    **kwargs: Any
72
) -> HibernateResourceOperationResponse:
73
    """
74
    Execute immediate hibernate operation on VMs without scheduling delay.
75
    
76
    Parameters:
77
    - locationparameter: Azure region where operation will be executed (required)
78
    - request_body: Execute hibernate request with execution parameters (required)
79
    
80
    Returns:
81
    Response containing operation ID and status information
82
    """
83
```
84

85
**Usage Example:**
86

87
```python
88
from azure.mgmt.computeschedule.models import (
89
    ExecuteHibernateRequest,
90
    ExecutionParameters,
91
    Resources,
92
    OptimizationPreference
93
)
94

95
# Configure immediate hibernate with optimization
96
execution_params = ExecutionParameters(
97
    resources=Resources(
98
        ids=["/subscriptions/{subscription_id}/resourceGroups/devRG/providers/Microsoft.Compute/virtualMachines/devWorkstation"]
99
    ),
100
    optimization_preference=OptimizationPreference.SPEED
101
)
102

103
request = ExecuteHibernateRequest(
104
    execution_parameters=execution_params
105
)
106

107
response = client.scheduled_actions.virtual_machines_execute_hibernate(
108
    locationparameter="westus2", 
109
    request_body=request
110
)
111

112
print(f"Immediate hibernate operation started with ID: {response.operation_id}")
113
```
114

115
### Execute Start Operation
116

117
Immediately start virtual machines, bringing stopped, deallocated, or hibernated VMs back online.
118

119
```python { .api }
120
def virtual_machines_execute_start(
121
    self, 
122
    locationparameter: str, 
123
    request_body: Union[ExecuteStartRequest, JSON, IO[bytes]], 
124
    **kwargs: Any
125
) -> StartResourceOperationResponse:
126
    """
127
    Execute immediate start operation on VMs without scheduling delay.
128
    
129
    Parameters:
130
    - locationparameter: Azure region where operation will be executed (required)
131
    - request_body: Execute start request with execution parameters (required)
132
    
133
    Returns:
134
    Response containing operation ID and status information
135
    """
136
```
137

138
**Usage Example:**
139

140
```python
141
from azure.mgmt.computeschedule.models import (
142
    ExecuteStartRequest,
143
    ExecutionParameters,
144
    Resources,
145
    RetryPolicy
146
)
147

148
# Configure immediate start with retry policy
149
retry_policy = RetryPolicy(
150
    retry_count=2,
151
    retry_window_in_minutes=15
152
)
153

154
execution_params = ExecutionParameters(
155
    resources=Resources(
156
        ids=[
157
            "/subscriptions/{subscription_id}/resourceGroups/prodRG/providers/Microsoft.Compute/virtualMachines/webServer",
158
            "/subscriptions/{subscription_id}/resourceGroups/prodRG/providers/Microsoft.Compute/virtualMachines/dbServer"
159
        ]
160
    ),
161
    retry_policy=retry_policy
162
)
163

164
request = ExecuteStartRequest(
165
    execution_parameters=execution_params
166
)
167

168
response = client.scheduled_actions.virtual_machines_execute_start(
169
    locationparameter="eastus",
170
    request_body=request
171
)
172

173
print(f"Immediate start operation initiated with ID: {response.operation_id}")
174
```
175

176
### Execute Create Operation
177

178
Create new virtual machine resources immediately based on provided configuration specifications.
179

180
```python { .api }
181
def virtual_machines_execute_create(
182
    self, 
183
    locationparameter: str, 
184
    request_body: Union[ExecuteCreateRequest, JSON, IO[bytes]], 
185
    **kwargs: Any
186
) -> CreateResourceOperationResponse:
187
    """
188
    Execute immediate create operation for new VMs.
189
    
190
    Parameters:
191
    - locationparameter: Azure region where VMs will be created (required)
192
    - request_body: Execute create request with resource configuration (required)
193
    
194
    Returns:
195
    Response containing operation ID and status information
196
    """
197
```
198

199
**Usage Example:**
200

201
```python
202
from azure.mgmt.computeschedule.models import (
203
    ExecuteCreateRequest,
204
    ResourceProvisionPayload
205
)
206

207
# Define VM creation configuration
208
resource_config = ResourceProvisionPayload(
209
    # VM configuration parameters would be defined here
210
    # This is a simplified example - actual implementation would include
211
    # detailed VM specifications, networking, storage, etc.
212
)
213

214
request = ExecuteCreateRequest(
215
    resource_config_parameters=resource_config
216
)
217

218
response = client.scheduled_actions.virtual_machines_execute_create(
219
    locationparameter="centralus",
220
    request_body=request
221
)
222

223
print(f"VM creation operation started with ID: {response.operation_id}")
224
```
225

226
### Execute Delete Operation
227

228
Immediately delete virtual machines and their associated resources permanently.
229

230
```python { .api }
231
def virtual_machines_execute_delete(
232
    self, 
233
    locationparameter: str, 
234
    request_body: Union[ExecuteDeleteRequest, JSON, IO[bytes]], 
235
    **kwargs: Any
236
) -> DeleteResourceOperationResponse:
237
    """
238
    Execute immediate delete operation on VMs.
239
    
240
    Parameters:
241
    - locationparameter: Azure region where VMs will be deleted (required)
242
    - request_body: Execute delete request with execution parameters (required)
243
    
244
    Returns:
245
    Response containing operation ID and status information
246
    """
247
```
248

249
**Usage Example:**
250

251
```python
252
from azure.mgmt.computeschedule.models import (
253
    ExecuteDeleteRequest,
254
    ExecutionParameters,
255
    Resources
256
)
257

258
# Configure VMs for immediate deletion
259
execution_params = ExecutionParameters(
260
    resources=Resources(
261
        ids=[
262
            "/subscriptions/{subscription_id}/resourceGroups/tempRG/providers/Microsoft.Compute/virtualMachines/tempVM1",
263
            "/subscriptions/{subscription_id}/resourceGroups/tempRG/providers/Microsoft.Compute/virtualMachines/tempVM2"
264
        ]
265
    )
266
)
267

268
request = ExecuteDeleteRequest(
269
    execution_parameters=execution_params
270
)
271

272
response = client.scheduled_actions.virtual_machines_execute_delete(
273
    locationparameter="westus",
274
    request_body=request
275
)
276

277
print(f"VM deletion operation started with ID: {response.operation_id}")
278
```
279

280
## Execution Configuration
281

282
### Resource Targeting
283

284
Specify target VMs using Azure Resource Manager resource IDs:
285

286
```python
287
from azure.mgmt.computeschedule.models import Resources
288

289
# Single VM
290
resources = Resources(
291
    ids=["/subscriptions/{subscription_id}/resourceGroups/{rg}/providers/Microsoft.Compute/virtualMachines/{vm_name}"]
292
)
293

294
# Multiple VMs across resource groups
295
resources = Resources(
296
    ids=[
297
        "/subscriptions/{subscription_id}/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm1",
298
        "/subscriptions/{subscription_id}/resourceGroups/rg2/providers/Microsoft.Compute/virtualMachines/vm2",
299
        "/subscriptions/{subscription_id}/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm3"
300
    ]
301
)
302
```
303

304
### Optimization Preferences
305

306
Control execution optimization for speed or cost:
307

308
```python
309
from azure.mgmt.computeschedule.models import OptimizationPreference
310

311
# Optimize for fastest execution
312
execution_params = ExecutionParameters(
313
    resources=resources,
314
    optimization_preference=OptimizationPreference.SPEED
315
)
316

317
# Optimize for lowest cost  
318
execution_params = ExecutionParameters(
319
    resources=resources,
320
    optimization_preference=OptimizationPreference.COST
321
)
322
```
323

324
### Retry Configuration  
325

326
Configure retry behavior for failed operations:
327

328
```python
329
from azure.mgmt.computeschedule.models import RetryPolicy
330

331
# Configure retry attempts
332
retry_policy = RetryPolicy(
333
    retry_count=3,              # Number of retry attempts
334
    retry_window_in_minutes=20  # Time window for retries
335
)
336

337
execution_params = ExecutionParameters(
338
    resources=resources,
339
    retry_policy=retry_policy
340
)
341
```