'Requests that a backup of the specified key be downloaded to the
client.
The Key Backup operation exports a key from Azure Key Vault in a
protected form. Note that this operation does NOT return key material
in a form that can be used outside the Azure Key Vault system, the
returned key material is either protected to a Azure Key Vault HSM or
to Azure Key Vault itself. The intent of this operation is to allow a
client to GENERATE a key in one Azure Key Vault instance, BACKUP the
key, and then RESTORE it into another Azure Key Vault instance. The
BACKUP operation may be used to export, in protected form, any key type
from Azure Key Vault. Individual versions of a key cannot be backed up.
BACKUP / RESTORE can be performed within geographical boundaries only;
meaning that a BACKUP from one geographical area cannot be restored to
another geographical area. For example, a backup from the US
geographical area cannot be restored in an EU geographical area.
:param vault_base_url: The vault name, for example
https://myvault.vault.azure.net.
:type vault_base_url: str
:param key_name: The name of the key.
:type key_name: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`BackupKeyResult
<azure.keyvault.models.BackupKeyResult>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`KeyVaultErrorException<azure.keyvault.models.KeyVaultErrorException>`'

def backup_key(self, vault_base_url, key_name, custom_headers=None, raw=False, **operation_config):

    url = '/keys/{key-name}/backup'
    path_format_arguments = {'vaultBaseUrl': self._serialize.url('vault_base_url', vault_base_url, 'str', skip_quote=True), 'key-name': self._serialize.url('key_name', key_name, 'str')}
    url = self._client.format_url(url, **path_format_arguments)
    query_parameters = {}
    query_parameters['api-version'] = self._serialize.query('self.api_version', self.api_version, 'str')
    header_parameters = {}
    header_parameters['Content-Type'] = 'application/json;    charset=utf-8'
    if self.config.generate_client_request_id:
        header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
    if custom_headers:
        header_parameters.update(custom_headers)
    if (self.config.accept_language is not None):
        header_parameters['accept-language'] = self._serialize.header('self.config.accept_language', self.config.accept_language, 'str')
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, **operation_config)
    if (response.status_code not in [200]):
        raise models.KeyVaultErrorException(self._deserialize, response)
    deserialized = None
    if (response.status_code == 200):
        deserialized = self._deserialize('BackupKeyResult', response)
    if raw:
        client_raw_response = ClientRawResponse(deserialized, response)
        return client_raw_response
    return deserialized
