0
# Backup Operations
1

2
Execution and management of backup operations including on-demand backups, backup scheduling, and backup job monitoring. Supports all Azure Backup workload types with comprehensive status tracking, job management, and operational monitoring capabilities.
3

4
## Capabilities
5

6
### Backup Execution
7

8
Core operations for triggering and managing backup jobs across all supported workload types.
9

10
```python { .api }
11
class BackupsOperations:
12
    def trigger(
13
        self,
14
        resource_group_name: str,
15
        vault_name: str,
16
        fabric_name: str,
17
        container_name: str,
18
        protected_item_name: str,
19
        parameters: BackupRequestResource,
20
        **kwargs
21
    ) -> None:
22
        """
23
        Trigger an on-demand backup for a protected item.
24

25
        Parameters:
26
        - resource_group_name: Resource group containing the vault
27
        - vault_name: Recovery Services vault name
28
        - fabric_name: Fabric name (usually "Azure")
29
        - container_name: Container hosting the protected item
30
        - protected_item_name: Name of the protected item
31
        - parameters: Backup request configuration
32
        - kwargs: Additional options
33

34
        Returns:
35
        None (operation is asynchronous - monitor via job operations)
36
        """
37
```
38

39
Usage example:
40

41
```python
42
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
43
    BackupRequestResource,
44
    IaasVMBackupRequest
45
)
46

47
# Trigger VM backup
48
backup_request = BackupRequestResource(
49
    properties=IaasVMBackupRequest(
50
        recovery_point_expiry_time_in_utc=datetime.utcnow() + timedelta(days=30)
51
    )
52
)
53

54
client.backups.trigger(
55
    resource_group_name="my-rg",
56
    vault_name="my-vault", 
57
    fabric_name="Azure",
58
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
59
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
60
    parameters=backup_request
61
)
62

63
print("Backup operation triggered successfully")
64
```
65

66
### Backup Job Management
67

68
Comprehensive backup job monitoring, tracking, and management operations.
69

70
```python { .api }
71
class BackupJobsOperations:
72
    def list(self, resource_group_name: str, vault_name: str, **kwargs) -> Iterable[JobResource]:
73
        """
74
        List backup jobs in a Recovery Services vault.
75

76
        Parameters:
77
        - resource_group_name: Resource group containing the vault
78
        - vault_name: Recovery Services vault name
79
        - kwargs: Filter options (status, operation, start_time, end_time, etc.)
80

81
        Returns:
82
        Iterable of JobResource objects
83
        """
84

85
    def get(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> JobResource:
86
        """
87
        Get details of a specific backup job.
88

89
        Parameters:
90
        - resource_group_name: Resource group containing the vault
91
        - vault_name: Recovery Services vault name
92
        - job_name: Name/ID of the backup job
93
        - kwargs: Additional options
94

95
        Returns:
96
        JobResource with detailed job information
97
        """
98

99
    def cancel(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> None:
100
        """
101
        Cancel a running backup job.
102

103
        Parameters:
104
        - resource_group_name: Resource group containing the vault
105
        - vault_name: Recovery Services vault name
106
        - job_name: Name/ID of the job to cancel
107
        - kwargs: Additional options
108
        """
109

110
    def export(self, resource_group_name: str, vault_name: str, **kwargs) -> None:
111
        """
112
        Export backup jobs to a storage account.
113

114
        Parameters:
115
        - resource_group_name: Resource group containing the vault
116
        - vault_name: Recovery Services vault name
117
        - kwargs: Export options (storage account, filters, etc.)
118
        """
119
```
120

121
Usage example:
122

123
```python
124
# List recent backup jobs
125
from datetime import datetime, timedelta
126

127
end_time = datetime.utcnow()
128
start_time = end_time - timedelta(days=7)
129

130
jobs = client.backup_jobs.list(
131
    "my-rg", "my-vault",
132
    filter=f"startTime eq '{start_time.isoformat()}' and endTime eq '{end_time.isoformat()}'"
133
)
134

135
for job in jobs:
136
    print(f"Job: {job.name}, Status: {job.properties.status}, Operation: {job.properties.operation}")
137

138
# Get specific job details
139
job_details = client.backup_jobs.get("my-rg", "my-vault", "job-id-12345")
140
print(f"Job Status: {job_details.properties.status}")
141
print(f"Start Time: {job_details.properties.start_time}")
142
print(f"End Time: {job_details.properties.end_time}")
143

144
# Cancel a running job
145
client.backup_jobs.cancel("my-rg", "my-vault", "job-id-12345")
146
```
147

148
### Advanced Job Operations
149

150
Extended job operations including job details, operation results, and status tracking.
151

152
```python { .api }
153
class JobsOperations:
154
    def list(self, resource_group_name: str, vault_name: str, **kwargs) -> Iterable[JobResource]:
155
        """List jobs with advanced filtering and pagination."""
156

157
    def get(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> JobResource:
158
        """Get job with comprehensive details."""
159

160
    def cancel(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> None:
161
        """Cancel job with validation."""
162

163
    def export(self, resource_group_name: str, vault_name: str, **kwargs) -> None:
164
        """Export jobs with custom parameters."""
165

166
class JobDetailsOperations:
167
    def get(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> JobResource:
168
        """Get detailed job information including sub-tasks and progress."""
169

170
class JobOperationResultsOperations:
171
    def get(self, resource_group_name: str, vault_name: str, job_name: str, operation_id: str, **kwargs) -> None:
172
        """Get result of job operation."""
173

174
class JobCancellationsOperations:
175
    def trigger(self, resource_group_name: str, vault_name: str, job_name: str, **kwargs) -> None:
176
        """Trigger job cancellation with tracking."""
177

178
class ExportJobsOperationResultsOperations:
179
    def get(self, resource_group_name: str, vault_name: str, operation_id: str, **kwargs) -> OperationResultInfoBaseResource:
180
        """Get result of job export operation."""
181
```
182

183
### Backup Status Operations
184

185
Operations for checking backup status and protection information.
186

187
```python { .api }
188
class BackupStatusOperations:
189
    def get(self, azure_region: str, parameters: BackupStatusRequest, **kwargs) -> BackupStatusResponse:
190
        """
191
        Get backup status for a resource.
192

193
        Parameters:
194
        - azure_region: Azure region name
195
        - parameters: Backup status request with resource details
196
        - kwargs: Additional options
197

198
        Returns:
199
        BackupStatusResponse with protection information
200
        """
201
```
202

203
Usage example:
204

205
```python
206
from azure.mgmt.recoveryservicesbackup.activestamp.models import BackupStatusRequest
207

208
# Check backup status for a VM
209
status_request = BackupStatusRequest(
210
    resource_type="VM",
211
    resource_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm",
212
    po_query_type="BackupStatus"
213
)
214

215
backup_status = client.backup_status.get("eastus", status_request)
216
print(f"Protection Status: {backup_status.protection_info.protection_status}")
217
print(f"Policy Name: {backup_status.protection_info.policy_name}")
218
```
219

220
## Backup Request Types
221

222
### IaaS VM Backup Request
223

224
Backup request specifically for Azure IaaS virtual machines.
225

226
```python { .api }
227
class IaasVMBackupRequest:
228
    def __init__(
229
        self,
230
        recovery_point_expiry_time_in_utc: Optional[datetime] = None,
231
        **kwargs
232
    ):
233
        """
234
        IaaS VM backup request.
235

236
        Parameters:
237
        - recovery_point_expiry_time_in_utc: Expiration time for the recovery point
238
        """
239

240
    recovery_point_expiry_time_in_utc: Optional[datetime]
241
```
242

243
### Azure File Share Backup Request
244

245
Backup request for Azure file shares with snapshot-based backup.
246

247
```python { .api }
248
class AzureFileShareBackupRequest:
249
    def __init__(
250
        self,
251
        recovery_point_expiry_time_in_utc: Optional[datetime] = None,
252
        **kwargs
253
    ):
254
        """
255
        Azure file share backup request.
256

257
        Parameters:
258
        - recovery_point_expiry_time_in_utc: Expiration time for the recovery point
259
        """
260

261
    recovery_point_expiry_time_in_utc: Optional[datetime]
262
```
263

264
### Azure Workload Backup Request
265

266
Backup request for workloads running inside Azure VMs.
267

268
```python { .api }
269
class AzureWorkloadBackupRequest:
270
    def __init__(
271
        self,
272
        backup_type: Optional[str] = None,
273
        enable_compression: Optional[bool] = None,
274
        recovery_point_expiry_time_in_utc: Optional[datetime] = None,
275
        **kwargs
276
    ):
277
        """
278
        Azure workload backup request.
279

280
        Parameters:
281
        - backup_type: Type of backup ("Full", "Differential", "Log", "CopyOnlyFull")
282
        - enable_compression: Whether to enable backup compression
283
        - recovery_point_expiry_time_in_utc: Expiration time for the recovery point
284
        """
285

286
    backup_type: Optional[str]
287
    enable_compression: Optional[bool]
288
    recovery_point_expiry_time_in_utc: Optional[datetime]
289
```
290

291
## Job Types
292

293
### Azure IaaS VM Job
294

295
Job information for Azure virtual machine backup operations.
296

297
```python { .api }
298
class AzureIaaSVMJob:
299
    def __init__(
300
        self,
301
        entity_friendly_name: Optional[str] = None,
302
        backup_management_type: str = "AzureIaasVM",
303
        operation: Optional[str] = None,
304
        status: Optional[str] = None,
305
        start_time: Optional[datetime] = None,
306
        end_time: Optional[datetime] = None,
307
        activity_id: Optional[str] = None,
308
        duration: Optional[str] = None,
309
        actions_info: Optional[List[str]] = None,
310
        error_details: Optional[List[AzureIaaSVMErrorInfo]] = None,
311
        virtual_machine_version: Optional[str] = None,
312
        extended_info: Optional[AzureIasSVMJobExtendedInfo] = None,
313
        **kwargs
314
    ):
315
        """
316
        Azure IaaS VM backup job.
317

318
        Parameters:
319
        - entity_friendly_name: Display name of the VM
320
        - backup_management_type: Always "AzureIaasVM" 
321
        - operation: Operation type ("Backup", "Restore", "ConfigureBackup", etc.)
322
        - status: Job status ("InProgress", "Completed", "Failed", etc.)
323
        - start_time: Job start time
324
        - end_time: Job end time (if completed)
325
        - activity_id: Unique activity identifier
326
        - duration: Job execution duration
327
        - actions_info: Available actions for the job
328
        - error_details: Error information if job failed
329
        - virtual_machine_version: VM version information
330
        - extended_info: Additional job details
331
        """
332

333
    entity_friendly_name: Optional[str]
334
    backup_management_type: str
335
    operation: Optional[str]
336
    status: Optional[str]
337
    start_time: Optional[datetime]
338
    end_time: Optional[datetime]
339
    activity_id: Optional[str]
340
    duration: Optional[str]
341
    actions_info: Optional[List[str]]
342
    error_details: Optional[List[AzureIaaSVMErrorInfo]]
343
    virtual_machine_version: Optional[str]
344
    extended_info: Optional[AzureIasSVMJobExtendedInfo]
345
```
346

347
### Azure Storage Job
348

349
Job information for Azure file share backup operations.
350

351
```python { .api }
352
class AzureStorageJob:
353
    def __init__(
354
        self,
355
        entity_friendly_name: Optional[str] = None,
356
        backup_management_type: str = "AzureStorage",
357
        operation: Optional[str] = None,
358
        status: Optional[str] = None,
359
        start_time: Optional[datetime] = None,
360
        end_time: Optional[datetime] = None,
361
        activity_id: Optional[str] = None,
362
        duration: Optional[str] = None,
363
        actions_info: Optional[List[str]] = None,
364
        error_details: Optional[List[AzureStorageErrorInfo]] = None,
365
        storage_account_name: Optional[str] = None,
366
        storage_account_version: Optional[str] = None,
367
        extended_info: Optional[AzureStorageJobExtendedInfo] = None,
368
        **kwargs
369
    ):
370
        """
371
        Azure Storage (file share) backup job.
372

373
        Parameters:
374
        - entity_friendly_name: Display name of the file share
375
        - backup_management_type: Always "AzureStorage"
376
        - operation: Operation type ("Backup", "Restore", "ConfigureBackup", etc.)
377
        - status: Job status
378
        - start_time: Job start time
379
        - end_time: Job end time (if completed)
380
        - activity_id: Unique activity identifier
381
        - duration: Job execution duration
382
        - actions_info: Available actions for the job
383
        - error_details: Error information if job failed
384
        - storage_account_name: Name of the storage account
385
        - storage_account_version: Storage account version
386
        - extended_info: Additional job details
387
        """
388

389
    entity_friendly_name: Optional[str]
390
    backup_management_type: str
391
    operation: Optional[str]
392
    status: Optional[str]
393
    start_time: Optional[datetime]
394
    end_time: Optional[datetime]
395
    activity_id: Optional[str]
396
    duration: Optional[str]
397
    actions_info: Optional[List[str]]
398
    error_details: Optional[List[AzureStorageErrorInfo]]
399
    storage_account_name: Optional[str]
400
    storage_account_version: Optional[str]
401
    extended_info: Optional[AzureStorageJobExtendedInfo]
402
```
403

404
### Azure Workload Job
405

406
Job information for workload backup operations (SQL, SAP HANA, etc.).
407

408
```python { .api }
409
class AzureWorkloadJob:
410
    def __init__(
411
        self,
412
        entity_friendly_name: Optional[str] = None,
413
        backup_management_type: str = "AzureWorkload",
414
        operation: Optional[str] = None,
415
        status: Optional[str] = None,
416
        start_time: Optional[datetime] = None,
417
        end_time: Optional[datetime] = None,
418
        activity_id: Optional[str] = None,
419
        duration: Optional[str] = None,
420
        actions_info: Optional[List[str]] = None,
421
        error_details: Optional[List[AzureWorkloadErrorInfo]] = None,
422
        workload_type: Optional[str] = None,
423
        extended_info: Optional[AzureWorkloadJobExtendedInfo] = None,
424
        **kwargs
425
    ):
426
        """
427
        Azure workload backup job.
428

429
        Parameters:
430
        - entity_friendly_name: Display name of the workload
431
        - backup_management_type: Always "AzureWorkload"
432
        - operation: Operation type ("Backup", "Restore", "ConfigureBackup", etc.)
433
        - status: Job status
434
        - start_time: Job start time
435
        - end_time: Job end time (if completed)
436
        - activity_id: Unique activity identifier
437
        - duration: Job execution duration
438
        - actions_info: Available actions for the job
439
        - error_details: Error information if job failed
440
        - workload_type: Type of workload ("SQLDataBase", "SAPHanaDatabase", etc.)
441
        - extended_info: Additional job details
442
        """
443

444
    entity_friendly_name: Optional[str]
445
    backup_management_type: str
446
    operation: Optional[str]
447
    status: Optional[str]
448
    start_time: Optional[datetime]
449
    end_time: Optional[datetime]
450
    activity_id: Optional[str]
451
    duration: Optional[str]
452
    actions_info: Optional[List[str]]
453
    error_details: Optional[List[AzureWorkloadErrorInfo]]
454
    workload_type: Optional[str]
455
    extended_info: Optional[AzureWorkloadJobExtendedInfo]
456
```
457

458
## Usage Examples
459

460
### Trigger Full VM Backup
461

462
```python
463
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
464
    BackupRequestResource,
465
    IaasVMBackupRequest
466
)
467
from datetime import datetime, timedelta
468

469
# Trigger immediate backup with 30-day retention
470
backup_request = BackupRequestResource(
471
    properties=IaasVMBackupRequest(
472
        recovery_point_expiry_time_in_utc=datetime.utcnow() + timedelta(days=30)
473
    )
474
)
475

476
client.backups.trigger(
477
    resource_group_name="my-rg",
478
    vault_name="my-vault",
479
    fabric_name="Azure", 
480
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
481
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
482
    parameters=backup_request
483
)
484
```
485

486
### Monitor Backup Jobs
487

488
```python
489
# List active backup jobs
490
active_jobs = client.backup_jobs.list(
491
    "my-rg", "my-vault",
492
    filter="status eq 'InProgress'"
493
)
494

495
for job in active_jobs:
496
    print(f"Job: {job.name}")
497
    print(f"Operation: {job.properties.operation}")
498
    print(f"Status: {job.properties.status}")
499
    print(f"Start Time: {job.properties.start_time}")
500
    
501
    # Get detailed job information
502
    job_details = client.job_details.get("my-rg", "my-vault", job.name)
503
    if hasattr(job_details.properties, 'extended_info'):
504
        print(f"Progress: {job_details.properties.extended_info.progress_percentage}%")
505
```
506

507
### Trigger SQL Database Backup
508

509
```python
510
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
511
    BackupRequestResource,
512
    AzureWorkloadBackupRequest
513
)
514

515
# Trigger SQL database full backup
516
sql_backup_request = BackupRequestResource(
517
    properties=AzureWorkloadBackupRequest(
518
        backup_type="Full",
519
        enable_compression=True,
520
        recovery_point_expiry_time_in_utc=datetime.utcnow() + timedelta(days=90)
521
    )
522
)
523

524
client.backups.trigger(
525
    resource_group_name="my-rg",
526
    vault_name="my-vault",
527
    fabric_name="Azure",
528
    container_name="vmappcontainer;compute;vm-rg;sql-vm",
529
    protected_item_name="sqldatabase;mssqlserver;sqldb01",
530
    parameters=sql_backup_request
531
)
532
```
533

534
### Export Job History
535

536
```python
537
# Export jobs to storage account for analysis
538
client.backup_jobs.export(
539
    resource_group_name="my-rg",
540
    vault_name="my-vault",
541
    # Export parameters would be in the request body
542
    container_uri="https://mystorageaccount.blob.core.windows.net/backupjobs",
543
    sas_token="?sv=2021-06-08&ss=b&srt=sco&sp=rwdlacupx&se=...",
544
    start_time=datetime.utcnow() - timedelta(days=30),
545
    end_time=datetime.utcnow()
546
)
547
```