Creating a protection plan

Authenticate to the cloud platform via the Python shell.

The following variables should be available now:

>>> base_url  # the base URL of the API
'https://eu2-cloud.acronis.com/api'
>>> auth  # the 'Authorization' header value with the access token
{'Authorization': 'Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImtpZCI6ImMwMD...'}

Import the uuid4 function from the uuid python module:
```
>>> from uuid import uuid4
```
Define a variable named protection_plan_id, and then assign the UUID generated with the uuid4() function and converted to string to this variable:
```
>>> protection_plan_id = str(uuid4())
'5b15f6e1-88ec-4dce-b523-0e8394c0bc19'
```

Define a variable named plan_data, and then assign an object with the subject key with an object containing the policy key with an array containing a total protection policy to this variable:

>>> plan_data = {
...     'subject': {
...         'policy': [
...             {
...                 'id': protection_plan_id,
...                 'type': 'policy.protection.total',
...                 'origin': 'upstream',
...                 'enabled': True,
...                 'name': 'My Protection Plan'
...             }
...         ]
...     }
... }

Define the variable named policies and assign it with the list of protection policy objects. As an example, a machine backup policy with default settings will be included:

Full code

policies = [
    {
        "id": str(uuid4()),
        # Machine backup policy type is 'policy.backup.machine'
        'type': 'policy.backup.machine',
        'parent_ids': [
            protection_plan_id
        ],
        'origin': 'upstream',
        'enabled': True,
        'settings_schema': '2.0',
        'settings': {
            # Archive compression level. Available values: ``normal``, ``high``, ``max``. When value is not specified - no compression is applied.
            'compression': 'normal',
            # Format of the Acronis backup archive. Available values: ``11``, ``12``, ``auto``.
            'format': 'auto',
            # If true, snapshots of multiple volumes will be taken simultaneously. Equals to false if value is not specified.
            'multi_volume_snapshotting_enabled': True,
            # If true, the file security settings will be preserved. Equals to false if value is not specified.
            'preserve_file_security_settings': True,
            # Configuration of retries on recoverable errors during the backup operations like reconnection to destination. No attempts to fix recoverable errors will be made if retry configuration is not set.
            'reattempts': {
                # If true, enables retry on recoverable errors.
                'enabled': True,
                # An interval between retry attempts.
                'interval': {
                    # A type of the interval. Available values are: ``seconds``, ``minutes``, ``hours``, ``days``.
                    'type': 'seconds',
                    # The amount of value specified in ``interval.type``.
                    'count': 30
                },
                # Max number of retry attempts. Operation will be considered as failed when max number of retry attempts is reached.
                'max_attempts': 30
            },
            # If true, a user interaction will be avoided when possible. Equals to false if value is not specified.
            'silent_mode_enabled': True,
            # Determines the size to split backups on. Splitting is not performed if value is not specified.
            'splitting': {
                # The size of split backup file in bytes.
                'size': 9223372036854775807
            },
            # Configuration of retries on errors during the creation of the virtual machine snapshot. No attempts to fix recoverable errors will be made if retry configuration is not set.
            'vm_snapshot_reattempts': {
                # If true, enables retry on errors.
                'enabled': True,
                # Configuration of the interval between retry attempts.
                'interval': {
                    # A type of the interval. Available values are: ``seconds``, ``minutes``, ``hours``, ``days``.
                    'type': 'minutes',
                    # The amount of value specified in ``interval.type``.
                    'count': 5
                },
                # Max number of retry attempts. Operation will be considered as failed when max number of retry attempts is reached.
                'max_attempts': 3
            },
            # Settings for the Volume Shadow Copy Service (VSS) provider. If not set, no VSS provider is used.
            'vss': {
                # If true, the VSS will be enabled.
                'enabled': True,
                # A type of VSS provider to use in backup. Only ``native`` and ``target_system_defined`` options are available.
                'provider': 'target_system_defined'
            },
            # The archive properties.
            'archive': {
                # The name of the generated archive. The name may use the following variables: ``[Machine Name]``, ``[Plan ID]``, ``[Plan Name]``, ``[Unique ID]``, ``[Virtualization Server Type]``.
                'name': '[Machine Name]-[Plan ID]-[Unique ID]A'
            },
            # Time windows for performance limitations of backup and storage maintenance operations.
            "performance_window": {
                "enabled": True,
                # A tuple of 3 presets
                "presets": [
                    {
                        # CPU priority - 'idle', 'low', 'normal', 'high', 'realtime'
                        "cpu_priority": "normal",
                        "disk_limit": {
                            # Value in specified units
                            "value": 50,
                            # Units. 'percent' - percentage, 'speed' - speed in kilobytes
                            "type": "percent"
                        },
                        # ID of preset. 'high' - green, 'low' - blue, 'cancel' - gray.
                        "id": "high",
                        "network_limit": {
                            # Value in specified units
                            "value": 50,
                            # Units. 'percent' - percentage, 'speed' - speed in kilobytes per second
                            "type": "percent"
                        },
                        # List of timetable objects
                        "timetable": [
                            {
                                # Time from which the preset applies
                                "time_from": {
                                    "hour": 0,
                                    "minute": 0
                                },
                                # Time until the preset applies
                                "time_to": {
                                    "hour": 23,
                                    "minute": 59,
                                    "second": 59
                                },
                                # Days of week in three-letter format
                                "days_of_week": [
                                    "sun",
                                    "mon",
                                    "tue",
                                    "wed",
                                    "thu",
                                    "fri",
                                    "sat"
                                ]
                            }
                        ]
                    },
                    {
                        "cpu_priority": "high",
                        "disk_limit": {
                            "value": 25,
                            "type": "percent"
                        },
                        "id": "low", # Blue preset
                        "network_limit": {
                            "value": 25,
                            "type": "percent"
                        },
                        "timetable": [
                            {
                                "time_from": {
                                    "hour": 8,
                                    "minute": 0
                                },
                                "time_to": {
                                    "hour": 8,
                                    "minute": 59,
                                    "second": 59
                                },
                                "days_of_week": [
                                    "sun",
                                    "fri"
                                ]
                            }
                        ]
                    },
                    {
                        "id": "cancel", # Gray (inactive) preset
                        "network_limit": {
                            "value": 100,
                            "type": "percent"
                        },
                        "disk_limit": {
                            "value": 100,
                            "type": "percent"
                        },
                        "timetable": [
                            {
                                "time_from": {
                                    "hour": 8,
                                    "minute": 0
                                },
                                "time_to": {
                                    "hour": 15,
                                    "minute": 59,
                                    "second": 59
                                },
                                "days_of_week": [
                                    "mon"
                                ]
                            }
                        ]
                    }
                ],
            },
            # Configuration of backup retention rules.
            'retention': {
                # A list of retention rules.
                'rules': [
                    {
                        # A list of backup sets where rules are effective.
                        'backup_set': [
                            'daily'
                        ],
                        # Configuration of the duration to keep backups in archive created by the policy.
                        'max_age': {
                            # A type of the duration. Available values are: ``seconds``, ``minutes``, ``hours``, ``days``.
                            'type': 'days',
                            # The amount of value specified in ``max_age.type``.
                            'count': 7
                        }
                    },
                    {
                        'backup_set': [
                            'weekly'
                        ],
                        'max_age': {
                            'type': 'weeks',
                            'count': 4
                        }
                    },
                    {
                        'backup_set': [
                            'monthly'
                        ],
                        'max_age': {
                            'type': 'months',
                            'count': 6
                        }
                    }
                ],
                # If true, retention rules will be applied after backup is finished.
                'after_backup': True
            },
            # Storage location of the archives.
            'vault': {
                # Type of storage location. Available values: ``local_folder``, ``network_share``, ``ftp``, ``sftp``, ``cd``, ``tape``, ``storage_node``, ``asz``, ``removable``, ``cloud``, ``nfs_share``, ``esx``, ``astorage2``, ``script``.
                'type': 'cloud',
                # If true, the vault will be accessed using the policy credentials.
                'use_policy_credentials': True
            },
            # Configuration of policy-related alerts.
            'alerts': {
                # If true, the alerts will be enabled.
                'enabled': False,
                # Number of days that will trigger the alert about the passed number of days without a backup.
                'max_days_without_backup': 5
            },
            # Configuration of the backup schedule.
            'scheduling': {
                # A list of schedules with backup sets that compose the whole scheme.
                'backup_sets': [
                    {
                        'type': 'auto',
                        'schedule': {
                            'alarms': {
                                'time': {
                                    'weekdays': [
                                        'mon',
                                        'tue',
                                        'wed',
                                        'thu',
                                        'fri'
                                    ],
                                    'repeat_at': [
                                        {
                                            'hour': 21,
                                            'minute': 0
                                        }
                                    ]
                                }
                            },
                            'conditions': {},
                            'prevent_sleep': True,
                            'type': 'weekly'
                        }
                    }
                ],
                # If true, the backup schedule will be enabled.
                'enabled': True,
                # Max number of backup processes allowed to run in parallel. Unlimited if not set.
                'max_parallel_backups': 2,
                'rand_max_delay': {  # Configuration of the random delay between the execution of parallel tasks.
                    # A type of the duration. Available values are: ``seconds``, ``minutes``, ``hours``, ``days``.
                    'type': 'minutes',
                    # The amount of value specified in ``rand_max_delay.type``.
                    'count': 30
                },
                # A backup scheme. Available values: ``simple``, ``always_full``, ``always_incremental``, ``weekly_incremental``, ``weekly_full_daily_incremental``, ``custom``, ``cdp``.
                'scheme': 'always_incremental',
                "task_failure": {
                    "enabled": True,
                    "interval": {
                        "type": "hours", # Time units - hours, minutes, seconds
                        "count": 1 # Number of time units
                    },
                    "max_attempts": 12 # Number of attempts between task restarts
                },
                # A day of week to start weekly backups in 3-letter abbreviation format.
                'weekly_backup_day': 'mon'
            },
            # A configuration of Changed Block Tracking (CBT). Available values: ``use_if_enabled``, ``enable_and_use``, ``do_not_use``.
            'cbt': 'enable_and_use',
            # If true, determines whether a file has changed by the file size and timestamp. Otherwise, the entire file contents are compared to those stored in the backup.
            'fast_backup_enabled': True,
            # If true, a quiesced snapshot of the virtual machine will be taken.
            'quiesce_snapshotting_enabled': True
        }
    },
    # Put other policy objects here.
]

For more policy settings, refer to Protection policy settings.

Merge the list of protection policy objects into the policy key of the plan_data object:
```
>>> plan_data['subject']['policy'] += policies
```

Convert the plan_data object to a JSON text:

>>> plan_data = json.dumps(plan_data, indent=4)

Send a POST request with the JSON text to the /policy_management/v4/policies endpoint:

>>> response = requests.post(
...     f'{base_url}/policy_management/v4/policies',
...     headers={'Content-Type': 'application/json', **auth},
...     data=plan_data,
... )

Check the status code of the response:

>>> response.status_code
200

Status code 200 means that the protection plan has been created.

A different status code means that an error has occurred. For the details, refer to “Status and error codes”.

Also, the response body contains an object with the result key containing an array of policy IDs formatted as a JSON text. When converted to an object, it will look as follows:

>>> pprint.pprint(response.json())
{'result': ['5b15f6e1-88ec-4dce-b523-0e8394c0bc19@policy.protection.total',
            '256f2ee5-c9fd-4aad-8607-97a977deeaae@policy.backup.machine',
            '260a95af-366f-4331-ad88-6f188f034870@policy.security.vulnerability_assessment',
            'fce55bf0-efb2-4220-b9bf-6fdebc5af660@policy.security.backups_scanning',
            'a1d5efa0-f9d7-4493-9bc9-c159879c7724@policy.security.windows_defender',
            '23f0fc3c-1b52-4da5-a765-fd856255b023@policy.security.patch_management',
            '9502bbc1-b37c-4617-8a8e-c174a945e98d@policy.security.microsoft_security_essentials',
            'f354c80f-5b7a-4466-97f1-df670cccb673@policy.security.antimalware_protection',
            '4f3c7359-2a83-40cf-9733-172253d85484@policy.security.data_protection_map',
            '3c496736-8fdf-48b7-bd4d-66c770448e83@policy.security.active_protection',
            '6c120d91-7ce3-463e-abae-b6c43ab27c87@policy.security.url_filtering']}