Base Acronis Cyber Platform API operations with Python

[[TOC]]

How to use examples

!!! note To successfully run samples Python version >= 3.6 is required.

To use those samples in your environment you should have pre-requirements installed.

requests>=2.22.0

To install those requirements, you can use provided requirements.txt

pip install -r requirements.txt

To use samples, move to the directory which contains the sample you want to run. Than run appropriate python script. They don't need parameters or request them interactively.

Most of scripts, just collect parameters and make corresponding API call directly with appropriate HTTP method, API endpoint URI and an authentication token received by Client during initialization based on data in cyber.platform.cfg.json file. Please, check Code Directory for scripts descriptions and The Acronis Cyber Platform API general workflow for the flow details. As well, this documents itself provides introduction to base operations with Acronis Cyber Platform API.

Code Directory

Folder name	File name	File description
`common`	`base_operations.py`	Contains code basis functions to call the API. As well as other utility functions, base sanity checks need to be performed before the API calls.
`common`	`__init__.py`	Tells `Python` that it's a module directory.
`authorization`	`create_api_client.py`	Creates an API Client (`client_id`, `client_secret`) to generate a JWT token and access the API. The Basic Authentication is used. For Acronis Cyber Protect (Acronis Cyber Cloud 9.0) the Management Console can be used to create an API Client. The result of the script is stored in clear text `api_client.json` file. It's raw answer from the API call. For your solutions, please, implement secured storage for `client_id`, `client_secret` as they are credentials to access the API. The scrip asks for login and password to create an API Client.
`authorization`	`issue_access_token.py`	Issue a JWT token to access the API. The token is expired in 2 hours. During the sanity checks in `base_operations.py` an expiration time for the current token is checked and a token is reissued if needed. The result of the script is stored in clear text `api_token.json` file. It's raw answer from the API call. For your solutions, please, implement secured storage for a JWT token info as they are credentials to access the API.
`authorization`	`issue_customer_scoped_token` `_for_bc.py`	Exchange a JWT token to a customer-scoped token to access protection API functionality. The token is expired as soon as the base token expired. Required to have `customer.json` to exchange a token. Not renewed automatically. Requires to be issued for all operations with plans and resources as they expected to be executed in a customer context.
`tenants`	`create_partner_tenant_and` `_assign_specific_edition.py`	Creates a partner with name Python Partner RANDOMSTRING v3.0 and enables all available offering items for them for an edition, specified in json configuration files `cyber.platform.cfg.json` and `cyber.platform.cfg.defaults.json`.
`tenants`	`create_customer_tenant_and` `_assign_specific_edition.py`	Creates a customer for Python Partner RANDOMSTRING v3.0 with name Python Customer RANDOMSTRING v3.0 and enables all available offering items for them for an edition, specified in json configuration files `cyber.platform.cfg.json` and `cyber.platform.cfg.defaults.json`.
`tenants`	`create_partner_tenant_and` `_assign_all_editions_available.py`	Creates a partner with name Python Partner All Editions RANDOMSTRING v3.0 and enables all available offering items for all available editions.
`tenants`	`create_partner_tenant_and` `_lock.py`	Creates a partner with name Python Locked Partner RANDOMSTRING v3.0 lock/unlock/disable/delete with prompt before operations to check in the Management Console.
`tenants`	`disable_all_applications` `_for_customer.py`	Disable all applications for previously created Python Customer RANDOMSTRING v3.0 customer.
`tenants`	`get_trial_end_date_` `for_customer_legacy.py`	Use version of a customer `pricing` info to identify edn-of-trial date for a customer in the trial state.
`tenants`	`get_trial_end_date_` `for_customer.py`	Use `production_start_date` of a customer `pricing` info to identify edn-of-trial date for a customer in the trial state.
`tenants`	`navigate_through_tenants.py`	Simple implementation of recursive tenant hierarchy browser.
`tenants`	`search_for_tenant_or_user.py`	Search for a tenant or user.
`tenants`	`switch_edition_for` `_customer_legacy.py`	Switch editions for a customer Python Switch Edition Customer RANDOMSTRING v3.0 using the legacy approach.
`tenants`	`switch_edition_for` `_customer.py`	Switch editions for a customer Python Switch Edition Customer RANDOMSTRING v3.0 using the current approach with a dry-run call.
`tenants`	`update_your_partners` `_to_all_available_editions.py`	Update all partners in underneath hierarchy to all currently available editions on your root tenant.
`tenants`	`update_your_partners_to_all` `_offering_items` `_for_specific_edition.py`	Update all partners in underneath hierarchy to enable all available offering items for the specified edition - enable new offering items scenario.
`agent`	`get_agent_installation_token.py`	Create an Agent installation token for a user personal tenant.
`agent`	`get_all_agents_info.py`	Get list of all Acronis Agents for tenants subtree where the root tenant is a tenant for which an API Client is created.
`agent`	`get_all_agents_info` `_for_customer.py`	Get list of all Acronis Agents for tenants subtree where the root tenant is a previously created customer.
`monitoring`	`activities_pagination.py`	Get the list of all activities with pagination.
`monitoring`	`alerts_pagination.py`	Get the list of all alerts with pagination.
`monitoring`	`tasks_pagination.py`	Get the list of all tasks with pagination.
`monitoring`	`get_tasks.py`	Get the list of all tasks competed during the last week.
`monitoring`	`get_activities.py`	Get the list of all activities competed during the last week.
`monitoring`	`get_alerts.py`	Get the list of all alerts competed during the last week.
`resources`	`create_dynamic_group.py`	Create a dynamic group for resources.
`resources`	`get_all_resources_info.py`	Get the list of all resources available in authorization scope.
`resources`	`get_all_resources_protection_statuses.py`	Get the list of all resources available in authorization scope with their protection statuses.
`plans`	`apply_plan.py`	Apply the first applicable plan for the first resource.
`plans`	`base_plan.json`	A backup plan template.
`plans`	`create_a_backup_plan.py`	Create a backup plan based on `base_plan.json` template.
`plans`	`get_all_plans_info.py`	the the list of all protection plans available in authorization scope.
`plans`	`revoke_plan.py`	Revoke the first applicable plan from the first resource.
`plans`	`start_plan_execution.py`	Start the first plan for the first resource execution.
`reports`	`create_report_retrieve.py`	Create an one time report to save for the root tenant, wait till its creation and download.
`reports`	`create_sku_report_retrieve.py`	Create an one time report for direct partners and SKU information included to save for the root tenant, wait till its creation and download.
`usage`	`get_tenant_usage.py`	Gets usage for the root tenant.
`users`	`create_user_for_customer` `_activate_assign` `_backup_user_role.py`	Creates a user for Customer.Bash.Examples.v3 and activate them by sending an e-mail and assign the `backup_user` role. The script asks for a username and an e-mail to create.
`users`	`create_user_for_partner` `_activate_assign` `_admin_role.py`	Creates a user for Partner.Bash.Examples.v3 and activate them by sending an e-mail and assign the `partner_admin` role. The script asks for a username and an e-mail to create.
`users`	`search_for_tenant_or_user.py`	Search for a tenant or user.
`users`	`ipmpersonate_user_call_me.py`	Impersonate the user created for the customer and call `/users/me` to check.
`pdf`	`README.pdf`	This guide rendered to PDF format.
	`LICENSE`	The license for the code. It's MIT license.
	`README.md`	This file.
	`cyber.platform.cfg.defaults.json`	Contains default configuration values for the scripts. They are used when the values are not defined in `cyber.platform.cfg.json` file.
	`cyber.platform.cfg.json`	Contains configuration values for the scripts.

The Acronis Cyber Platform API general workflow

#	Operation	When/Period	Prerequisites / Inputs
1	Create an API client under which an integration will be authorized	Initially. Periodically if security policies require your company to regenerate all passwords each X months. Through the API or the Management Portal for ACC 9.0 and greater.	Login and password with a needed level of access in Acronis Cyber Cloud. Usually, it's a service Admin account under your company’s Partner tenant in Acronis Cyber Cloud.
2	Issue an access token	1. Before the first API Call which is not connected to the authorization flow 2. Each time when your token is near to be expired.	Your API Client credentials
3	Make API calls		An access token issued using your API Client credentials

Prerequisites and basis information

To run the scripts, you need to edit or create the cyber.platform.cfg.json file to provide base parameters. At minimum you need to change base_url to your data center URL. The Config class is initialized from the config file and used for all API requests. All other values can remain unchanged. A cyber.platform.cfg.json file example:

{
  "base_url": "https://dev-cloud.acronis.com/",
  "partner_tenant": "partner",
  "customer_tenant": "customer",
  "edition": "pck_per_gigabyte",
  "switch_edition": "pck_per_workload",
  "cyber_protection_application_id": "6e6d758d-8e74-3ae3-ac84-50eb0dff12eb"
}

Create an API Client to access the API

A JWT token with a limited time to life approach is used to securely manage access of any API clients, like our scripts, for the Acronis Cyber Cloud. Using a login and password for a specific user is not a secure and manageable way to create a token, but technically it's possible. Thus, we create an API client with a client id and a client secret to use as credentials to issue a JWT token. To create an API Client, we call the /clients end-point with POST request specifying in the JSON body of the request a tenant we want to have access to. To authorize this the request, the Basic Authorization with user login and password for Acronis Cyber Cloud is used.

!!! note In Acronis Cyber Cloud 9.0 API Client credentials can be generated in the Management Portal.

!!! note Creating an API Client is a one-time process. As the API client is used to access the API, treat it as credentials and store securely. Also, do not store the login and password in the scripts itself.

In the following code block a login and a password are requested from a command line and use it for a Basic Authorization for following HTTP requests.

# Read username and password from a command line
username = input("Username: ")
password = getpass.getpass(prompt="Password: ")

In those scripts it is expected that the Acronis Developer Sandbox is used. It is available for registered developers at Acronis Developer Network Portal. So the base URL for all requests (https://devcloud.acronis.com/) is used. Please, replace it with correct URL for your production environment if needed. For more details, please, review the Authenticating to the platform via the Python shell tutorial from the Acronis Cyber Platform documentation.

For demo purposes, this script issues an API client for a tenant for a user for whom a login and a password are specified. You should add your logic as to what tenant should be used for the API Client creation.

# Request information about a user which is authenticated by
# username and password - Basic Authentication
response = requests.get(
    f'{cfg.base_url}api/2/users/me',
    auth=(username, password)
)

if response.ok:
    # Read tenant_id from received JSON
    my_tenant_id = response.json()["tenant_id"]

    # Build an object represents an API Client creation request JSON body
    client = {
        "type": "api_client",
        "tenant_id": f"{my_tenant_id}",
        "token_endpoint_auth_method": "client_secret_basic",
        "data": {
            "client_name": "Python.Client"
        }
    }

    ...

else:
    pprint.pprint(response.json())

!!! note client_name value defines the name you will see in the ACC 9.0 Management Console. For real integrations, please, name it carefully to have a way to identify it in a future.

# Create an API Client with Basic Authentication
response = requests.post(
    f'{cfg.base_url}api/2/clients',
    headers={**cfg.header, **{'Content-Type': 'application/json'}},
    auth=(username, password),
    data=json.dumps(client)
)

if response.ok:
    # Save the created API Client info to api_client.json file
    with open(os.path.join(base_path, 'api_client.json'), 'w') as outfile:
        json.dump(response.json(), outfile)
else:
    pprint.pprint(response.json())

!!! note A generated client inherits access rights from a user used for the generation but it's disconnected from them. You don't need to issue a new client even if the user account is removed from Acronis Cloud.

!!! warning Treat API Clients as a specific service account with access to your cloud. All internal security policies applied to your normal account operations should be in place for API Clients. Thus, don't create new API Clients unless really required.

!!! warning You can receive a client_secret only once when client_secret is issued. If you lose your client_secret further you must reset secret for the client through the Management Console or API Calls. Please, be aware, that all tokens are invalidated on secret reset.

!!! danger You need to securely store the received credentials. For simplicity of the demo code, a simple JSON format is used for api_client.json file. Please remember to implement secure storage for your client credentials.

Issue a token to access the API

A client_id and a client_secret can be used to access the API using the Basic Authorization but it's not a secure way as we discussed above. It's more secure to have a JWT token with limited life-time and implement a renew/refresh logic for that token.

To issue a token /idp/token end-point is called using POST request with param grant_type equal client_credentials and content type application/x-www-form-urlencoded with Basic Authorization using a client_id as a user name and a client_secret as a password.

with open(os.path.join(base_path, 'api_client.json')) as api_client_file:
    api_client_json = json.load(api_client_file)

client_id = api_client_json["client_id"]
client_secret = api_client_json["client_secret"]

response = requests.post(
    f'{cfg.base_url}api/2/idp/token',
    headers={**cfg.header, **{'Content-Type': 'application/x-www-form-urlencoded'}},
    auth=(client_id, client_secret),
    data={'grant_type': 'client_credentials'}
)

if response.ok:
    with open(os.path.join(base_path, 'api_token.json'), 'w') as outfile:
        json.dump(response.json(), outfile)
else:
    pprint.pprint(response.json())

!!! danger You need to securely store the received token. For simplicity of the demo code, the received JSON format is used api_token.json file. Please implement secure storage for your tokens.

!!! note A token has time-to-live and must be renewed/refreshed before expiration time. The best practice is to check before starting any API calls sequence and renew/refresh if needed.

!!! note Currently, the default time-to-live to a token for the API is 2 hours.

Assuming that the token is stored in the JSON response format as above, it can be done using the following functions set.

expires_on is a time when the token will expire in Unix time format -- seconds from January 1, 1970. Here we assume that we will renew/refresh a token 15 minutes before the expiration time.

# Check if the token valid at least 15 minutes
def __read_token(self):
    if os.path.exists(os.path.join(base_path, 'api_token.json')):
        with open(os.path.join(base_path, 'api_token.json')) as api_token_file:
            self.__api_token = json.load(api_token_file)
            expires_on = self.__api_token["expires_on"]
            if expires_on - time() < 900:
                self.__issue_token()
    elif os.path.exists(os.path.join(base_path, 'api_client.json')):
        self.__issue_token()

 def __issue_token(self):
    if os.path.exists(os.path.join(base_path, 'api_client.json')):
        client_id = self.__api_client["client_id"]
        client_secret = self.__api_client["client_secret"]

        response = requests.post(
            f'{self.base_url}api/2/idp/token',
            headers={'Content-Type': 'application/x-www-form-urlencoded'},
            auth=(client_id, client_secret),
            data={'grant_type': 'client_credentials'}
        )

        if response.ok:
            self.__api_token = response.json()
            self.access_token = self.__api_token["access_token"]
            with open(os.path.join(base_path, 'api_token.json'), 'w') as outfile:
                json.dump(self.__api_token, outfile)
        else:
            pprint.pprint(response.json())

Create partner, customer and user tenants and set offering items

So now we can securely access the Acronis Cyber Platform API calls. In this topic we discuss how to create a partner, a customer tenants and enable for them all available offering items, and then create a user for the customer and activate the user by setting a password.

As we discussed above, before making a call to the actual API you need to ensure that an authorization token is valid. Please, use the functions like those described above to do it.

Assuming that we create the API client for our root tenant, we start from retrieving the API Client tenant information using GET request to /clients/{clientId} end-point. Then, using received tenant_id information as a parameter and kind equal to partner, we build a JSON body for POST request to /tenants end-point to create the partner. Next, we are going to enable all applications and offering items for the tenants. Briefly, we take all available offering items for the parent tenant of the partner or the customer using GET request to /tenants/{tenantId}/offering_items/available_for_child end-point with needed query parameters specifying edition and kind of the tenant. Then, we need to enable these offering items for the partner or the customer using PUT request to /tenants/{tenantId}/offering_items end-point with all offering items JSON in the request body and appropriate tenantId.

!!! note The following kind values are supported partner, folder, customer, unit.

# Initialize config and read all required values form JSON config
# an API client and a token files
cfg = Config(full=True)
acronis = Acronis(cfg)

partner = {
    "name": f"Python Partner {id_generator()} v3.0",
    "parent_id": f"{cfg.tenant_id}",
    "kind": f"{cfg.partner_tenant}"
}

response = acronis.post(
            'api/2/tenants',
            data=json.dumps(partner)
)

if response.ok:
    with open(os.path.join(base_path, 'partner.json'), 'w') as outfile:
        json.dump(response.json(), outfile)

    new_partner = Tenant(os.path.join(base_path, 'partner.json'))

    response = acronis.get(
        f'api/2/tenants/{cfg.tenant_id}/offering_items/available_for_child?kind={cfg.partner_tenant}&edition={cfg.edition}'
    )

    if response.ok:

        offering_items = json.loads('{"offering_items":[]}')
        offering_items["offering_items"] = response.json()["items"]

        response = acronis.put(
            f'api/2/tenants/{new_partner.tenant_id}/offering_items',
            data=json.dumps(offering_items)
        )

        if response.ok:
            print(f"Offering items were set for tenant {new_partner.tenant_id}")
        else:
            pprint.pprint(response.json())
    else:
        pprint.pprint(response.json())
else:
    pprint.pprint(response.json())

This is absolutely the same process as for a customer, the only difference is kind equal to customer in the request body JSON and /offering_items/available_for_child parameters.

# Initialize config and read all required values form JSON config
# an API client and a token files
cfg = Config(full=True)
acronis = Acronis(cfg)

partner = Tenant(os.path.join(base_path, 'partner.json'))

customer = {
    "name": f"Python Customer {id_generator()} v3.0",
    "parent_id": f"{partner.tenant_id}",
    "kind": f"{cfg.customer_tenant}"
}

response = acronis.post(
     'api/2/tenants',
     data=json.dumps(customer)
)

if response.ok:
    with open(os.path.join(base_path, 'customer.json'), 'w') as outfile:
        json.dump(response.json(), outfile)

    new_customer = Tenant(os.path.join(base_path, 'customer.json'))

    response = acronis.get(
        f'api/2/tenants/{cfg.tenant_id}/offering_items/available_for_child?kind={cfg.customer_tenant}&edition={cfg.edition}'
    )

    if response.ok:

        offering_items = json.loads('{"offering_items":[]}')
        offering_items_to_filter = response.json()["items"]

        # Only 1 location for a customer as well only 1 storage of 1 type
        # ba2976d0-c13e-4661-ae60-b4593583fce2 - Google DR storage for dev-cloud
        filtered_offering_items = [oi for oi in offering_items_to_filter if (oi["type"] == 'infra' and oi["infra_id"] != 'ba2976d0-c13e-4661-ae60-b4593583fce2') or (oi["type"] != 'infra')]
        filtered_offering_items = [oi for oi in filtered_offering_items if (oi["type"] == 'feature' and oi["usage_name"].startswith("dr_") and oi["infra_id"] != 'ba2976d0-c13e-4661-ae60-b4593583fce2') or (oi["type"] != 'feature') or not oi["usage_name"].startswith("dr_")]

        offering_items["offering_items"] = filtered_offering_items

        with open(os.path.join(base_path, 'customer_offering_items.json'), 'w') as outfile:
            json.dump(offering_items, outfile)

        response = acronis.put(
            f'api/2/tenants/{new_customer.tenant_id}/offering_items',
            data=json.dumps(offering_items)
        )

        if response.ok:
            print(f"Offering items were set for tenant {new_customer.tenant_id}")

        else:
            pprint.pprint(response.json())
    else:
        pprint.pprint(response.json())
else:
    pprint.pprint(response.json())

By default, customers are created in a trial mode. To switch to production mode we need to update customer pricing. To perform this task, we start from requesting current pricing using a GET request to /tenants/{customerTenantId}/pricing end-point then change mode property to production in the received JSON, then, finally, update the pricing using PUT request to /tenants/{customerTenantId}/pricing end-point with a new pricing JSON.

!!! warning Please, be aware, that this switch is non-revertible.

response = acronis.get(
    f'api/2/tenants/{new_customer.tenant_id}/pricing'
)

if response.ok:

    pricing = response.json()
    pricing["mode"] = "production"

    response = acronis.put(
        f'api/2/tenants/{new_customer.tenant_id}/pricing',
        data=json.dumps(pricing)
    )

    if response.ok:
        print(f"Customer tenant {new_customer.tenant_id} pricing set to production mode.")
    else:
        pprint.pprint(response.json())
else:
    pprint.pprint(response.json())

Finally, we create a user for the customer. At first, we check if a login is available using GET request to /users/check_login end-point with username parameter set to an expected login. Then, we create a JSON body for POST request to /users end-point to create a new user.

# Initialize config and read all required values form JSON config
# an API client and a token files
cfg = Config(full=True)
acronis = Acronis(cfg)

login = input("New login: ")
email = input("Please enter a valid email, it will be used for account activation: ")

response = acronis.get(
    f"api/2/users/check_login?username={login}"
)

if response.ok and response.status_code == 204:
    customer = Tenant(os.path.join(base_path, "customer.json"))

    user = {
        "tenant_id": f"{customer.tenant_id}",
        "login": f"{login}",
        "contact": {
            "email": f"{email}",
            "firstname": f"First {login}",
            "lastname": f"Last {login}"
            }
        }

    response = acronis.post(
        'api/2/users',
        data=json.dumps(user)
    )

    if response.ok:
        with open(os.path.join(base_path, 'user.json'), 'w') as outfile:
            json.dump(response.json(), outfile)
    else:
        pprint.pprint(response.json())
else:
    pprint.pprint(response.json())

A created user is not active. To activate them we can either send them an activation e-mail or set them a password. The sending of an activation e-mail is the preferable way.

new_user = User(os.path.join(base_path, 'user.json'))

response = acronis.post(
    f'api/2/users/{new_user.id}/send-activation-email'
)

if response.ok:
    print(f"User {login} is activated by sending an e-mail.")
else:
    pprint.pprint(response.json())

At this point, we've created a partner, a customer, enable offering items for them, create a user and activate them.

!!! note The created user has no roles assigned. It means it can't use any service. To enable services/applications you need to assign an appropriate role to a user.

!!! note All operations with the user account roles are located under the /users/{user_id}/access_policies endpoint.

!!! note To build a JSON to assign a role for a user id and user personal_tenant_id need to be known. All these values can be retrieved from the user.json file we've received as result of the user creation API call.

user_role = {
    "items": [
        {
            "id": "00000000-0000-0000-0000-000000000000",
            "issuer_id": "00000000-0000-0000-0000-000000000000",
            "role_id": "backup_user",
            "tenant_id": f"{customer.tenant_id}",
            "trustee_id": f"{new_user.id}",
            "trustee_type": "user",
            "version": 0
        }
    ]
}

response = acronis.put(
          f'api/2/users/{new_user.id}/access_policies',
          data=json.dumps(user_role)
        )

Get a tenant usage

A very common task is to check a tenant’s usage. It's a simple task. We just need to make a GET request to /tenants/{tenantId}/usages end-point, as result we receive a list with current usage information in JSON format.

!!! warning The information about a service usage of the tenant, provided by the /tenants/{tenantId}/usages endpoint, is updated on average every 0.5 hours and must not be used for billing purposes.

# Initialize config and read all required values form JSON config
# an API client and a token files
cfg = Config(full=True)
acronis = Acronis(cfg)

response = acronis.get(
    f'api/2/tenants/{cfg.tenant_id}/usages'
)

if response.ok:
    with open(os.path.join(base_path, f'tenant_usage_{cfg.tenant_id}.json'), 'w') as outfile:
        json.dump(response.json(), outfile)
else:
    pprint.pprint(response.json())

!!! note It's very useful to store usage information for further processing. In our example we use response JSON format to store it in a file.

Create and download simple report

The reporting capability of the Acronis Cyber Cloud gives you advanced capabilities to understand usage. In the following simple example, we create a one-time report in csv format, and then download it. To check other options, please, navigate to the Acronis Cyber Platform documentation.

To create a report to save, we build a body JSON and make a POST request to /reports end-point. Then we look into stored reports with specified reportId making a GET request to /reports/{reportId}/stored endpoint.

# Initialize config and read all required values form JSON config
# an API client and a token files
cfg = Config(full=True)
acronis = Acronis(cfg)

report = {
    "parameters": {
        "kind": "usage_current",
        "tenant_id": f"{cfg.tenant_id}",
        "level": "accounts",
        "formats": [
            "csv_v2_0"
        ]
    },
    "schedule": {
        "type": "once"
    },
    "result_action": "save"
}

response = acronis.post(
    'api/2/reports',
    data=json.dumps(report)
)

if response.ok:
    report_status = "non saved"
    report_id = response.json()["id"]
    stored_report_id = None

    while report_status != "saved":
        response = acronis.get(
            f'api/2/reports/{report_id}/stored'
         )

        if response.ok:
            report_status = response.json()["items"][0]["status"]
        else:
            pprint.pprint(response.json())

        time.sleep(2)

    stored_report_id = response.json()["items"][0]["id"]

    response = acronis.get(
        f'api/2/reports/{report_id}/stored/{stored_report_id}',
        )

    if response.ok:
        with open(os.path.join(base_path, f'report_for_tenant_{cfg.tenant_id}.csv'), 'w') as outfile:
            outfile.write(response.text)
    else:
        pprint.pprint(response.json())
else:
    pprint.pprint(response.json())

Add marks to your API calls for better support

It's technically possibly to identify your API calls as they are connected to your API Client. But still it's required a lot of efforts and hard to find in your Audit log at the Management Portal for your. Thus to better support your development effort it would be a great idea to identify your integrations and API calls somehow. Traditional way to do it in a RESTFul word is using the User-Agent header.

There are common recommendations how to build your User-Agent header:

User-Agent: <product>/<product-version> <comment>

For example, for our hands-on lab, you can use:

User-Agent: Training/1.0 Acronis #CyberFit Developers Business Automation Training

To implement it using our Python examples, we need just add the header to each request call using API have header：

 self.header = {"User-Agent": "ACP 3.0/Acronis Cyber Platform Python Examples"}

!!! Warning Please, for a real integration, use your real integration name, a specific version and suitable comments to simplify your support.

Summary

Now you know how to use base operations with the Acronis Cyber Platform API:

Create an API Client for the Acronis Cyber Platform API access
Issue a token for secure access for the API
Establish a simple procedure to renew/refresh the token
Create a partner and a customer tenants and enable offering items for them.
Create a user for a customer tenant and activate them.
Enable services for a user by assigning a role.
Receive simple usage information for a tenant.
Create and download reports for usage.

Get started today, register on the Acronis Developer Portal and see the code samples available, you can also review solutions available in the Acronis Cyber Cloud Solutions Portal.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

README.md

README.md

Base Acronis Cyber Platform API operations with Python

How to use examples

Code Directory

The Acronis Cyber Platform API general workflow

Prerequisites and basis information

Create an API Client to access the API

Issue a token to access the API

Create partner, customer and user tenants and set offering items

Get a tenant usage

Create and download simple report

Add marks to your API calls for better support

Summary

Files

README.md

Latest commit

History

README.md

File metadata and controls

Base Acronis Cyber Platform API operations with Python

How to use examples

Code Directory

The Acronis Cyber Platform API general workflow

Prerequisites and basis information

Create an API Client to access the API

Issue a token to access the API

Create partner, customer and user tenants and set offering items

Get a tenant usage

Create and download simple report

Add marks to your API calls for better support

Summary