IBM Backup Recovery API | IBM Cloud API Docs

Introduction

Last updated: 2025-04-01

The IBM Cloud Backup and Recovery API is a REST-based API to back up either application-consistent workloads. It uses IBM Cloud® Identity and Access Management for authentication/authorization.

For details about using IBM Cloud Backup and Recovery, see the IBM Cloud docs.

IBM Cloud Backup and Recovery is a regional service. The location of data is determined by the region where the instance is created, and subsequent requests to that instance must be sent to the corresponding instance service endpoint. For more details about selecting endpoints for IBM Cloud Backup and Recovery, see the IBM Cloud docs.

Go developers can use this SDK to interact with IBM Cloud Backup and Recovery. For more information, see the Go SDK API Reference.

The Backup and Recovery service uses standard HTTP response codes to indicate if a method completes successfully. A 2xx response always indicates success. A 4xx type response is some sort of failure, and a 5xx type response usually indicates an internal system error.

For more details about response codes for Backup and Recovery, see the IBM Cloud docs.

The code examples on this tab use the client library that is provided for Go.

go get -u github.com/IBM/ibm-backup-recovery-sdk-go

GitHub

https://github.com/IBM/ibm-backup-recovery-sdk-go

Download agent for different hosts

POST /data-protect/agents/download

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

DownloadAgentRequestParams

Specifies agent details

Download an agent

linuxAgentParams := &backupRecovery.LinuxAgentParams{
  PackageType: core.StringPtr("kRPm"),
}
downloadAgentOptions := &backupRecovery.DownloadAgentOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  Platform:    core.StringPtr("kLinux"),
  LinuxParams: linuxAgentParams,
}
result, response, _ := service.DownloadAgent(downloadAgentOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

binary

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Get the list of agent upgrade tasks

GET /data-protect/agents/upgrade-tasks

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Query Parameters

ids
int64[]
Specifies IDs of tasks to be fetched

Get Agent upgrade tasks

getUpgradeTasksOptions := &backupRecovery.GetUpgradeTasksOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
}
result, response, _ := service.GetUpgradeTasks(getUpgradeTasksOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

AgentUpgradeTaskStates

List of agent upgrade tasks

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Create a schedule-based agent upgrade task

POST /data-protect/agents/upgrade-tasks

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

CreateUpgradeTaskRequest

Specifies parameters to create a schedule-based agent upgrade task

Create an upgrade task

createUpgradeTaskOptions := &backupRecovery.CreateUpgradeTaskOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  AgentIDs: []int64{4},
}
result, response, _ := service.CreateUpgradeTask(createUpgradeTaskOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

AgentUpgradeTaskState

Specifies the state of an agent upgrade task

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

List the snapshots for a given object

GET /data-protect/objects/{id}/snapshots

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
int64
Specifies the id of the Object

Query Parameters

fromTimeUsecs
int64
Specifies the timestamp in Unix time epoch in microseconds to filter Object's snapshots which were taken after this value
toTimeUsecs
int64
Specifies the timestamp in Unix time epoch in microseconds to filter Object's snapshots which were taken before this value
runStartFromTimeUsecs
int64
Specifies the timestamp in Unix time epoch in microseconds to filter Object's snapshots which were run after this value
runStartToTimeUsecs
int64
Specifies the timestamp in Unix time epoch in microseconds to filter Object's snapshots which were run before this value
snapshotActions
string[]
Specifies a list of recovery actions. Only snapshots that apply to these actions will be returned

Allowable values: [RecoverVMs,RecoverFiles,InstantVolumeMount,RecoverVmDisks,MountVolumes,RecoverVApps,RecoverRDS,RecoverAurora,RecoverS3Buckets,RecoverApps,RecoverNasVolume,RecoverPhysicalVolumes,RecoverSystem,RecoverSanVolumes,RecoverNamespaces,RecoverObjects,DownloadFilesAndFolders,RecoverPublicFolders,RecoverVAppTemplates,RecoverMailbox,RecoverOneDrive,RecoverMsTeam,RecoverMsGroup,RecoverSharePoint,ConvertToPst,RecoverSfdcRecords,RecoverAzureSQL,DownloadChats,RecoverRDSPostgres,RecoverMailboxCSM,RecoverOneDriveCSM,RecoverSharePointCSM]
Possible values: contains only unique items
runTypes
string[]
Filter by run type. Only protection runs matching the specified types will be returned. By default, CDP hydration snapshots are not included unless explicitly queried using this field

Allowable values: [kRegular,kFull,kLog,kSystem,kHydrateCDP,kStorageArraySnapshot]
Possible values: contains only unique items
protectionGroupIds
string[]
If specified, this returns only the snapshots of the specified object ID, which belong to the provided protection group IDs
runInstanceIds
int64[]
Filter by a list of run instance IDs. If specified, only snapshots created by these protection runs will be returned
regionIds
string[]
Filter by a list of region IDs
objectActionKeys
string[]
Filter by ObjectActionKey, which uniquely represents the protection of an object. An object can be protected in multiple ways but at most once for a given combination of ObjectActionKey. When specified, only snapshots matching the given action keys are returned for the corresponding object

Allowable values: [kVMware,kHyperV,kVCD,kAzure,kGCP,kKVM,kAcropolis,kAWS,kAWSNative,kAwsS3,kAWSSnapshotManager,kRDSSnapshotManager,kAuroraSnapshotManager,kAwsRDSPostgresBackup,kAwsRDSPostgres,kAwsAuroraPostgres,kAzureNative,kAzureSQL,kAzureSnapshotManager,kPhysical,kPhysicalFiles,kGPFS,kElastifile,kNetapp,kGenericNas,kIsilon,kFlashBlade,kPure,kIbmFlashSystem,kSQL,kExchange,kAD,kOracle,kView,kRemoteAdapter,kO365,kO365PublicFolders,kO365Teams,kO365Group,kO365Exchange,kO365OneDrive,kO365Sharepoint,kKubernetes,kCassandra,kMongoDB,kCouchbase,kHdfs,kHive,kHBase,kSAPHANA,kUDA,kSfdc,kO365ExchangeCSM,kO365OneDriveCSM,kO365SharepointCSM]

Get Agent upgrade tasks

getObjectSnapshotsOptions := &backupRecovery.GetObjectSnapshotsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.Int64Ptr(1),
}
result, response, _ := service.GetObjectSnapshots(getObjectSnapshotsOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

GetObjectSnapshotsResponse

Specifies the list of object snapshots

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Lists protection policies based on filtering query parameters

GET /data-protect/policies

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Query Parameters

ids
string[]
Filter policies by a list of policy ids
policyNames
string[]
Filter policies by a list of policy names
types
string[]
Types specifies the policy type of policies to be returned

Allowable values: [Regular,Internal]
excludeLinkedPolicies
boolean
If excludeLinkedPolicies is set to true then only local policies created on cluster will be returned. The result will exclude all linked policies created from policy templates
includeReplicatedPolicies
boolean
If includeReplicatedPolicies is set to true, then response will also contain replicated policies. By default, replication policies are not included in the response
includeStats
boolean
If includeStats is set to true, then response will return number of protection groups and objects. By default, the protection stats are not included in the response

List Protection Policies

getProtectionPoliciesOptions := &backupRecovery.GetProtectionPoliciesOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
}
result, response, _ := service.GetProtectionPolicies(getProtectionPoliciesOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ProtectionPoliciesResponse

Specifies the details about the Protection Policy

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Create the Protection Policy and returns the newly created policy object

POST /data-protect/policies

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

ProtectionPolicyRequest

Request to create a Protection Policy

Create a Protection Policy

runScheduleOptions := &backupRecovery.IncrementalSchedule{
  Unit: core.StringPtr("Minutes"),
  MinuteSchedule: &backupRecovery.MinuteSchedule{
    Frequency: core.Int64Ptr(2),
  },
}
incrementalFullRetentionPolicyOptions := &backupRecovery.IncrementalBackupPolicy{
  Schedule: runScheduleOptions,
}
retentionOptions := &backupRecovery.Retention{
  Unit:     core.StringPtr("Weeks"),
  Duration: core.Int64Ptr(1),
}
regularBackupPolicyOptions := &backupRecovery.RegularBackupPolicy{
  Incremental: incrementalFullRetentionPolicyOptions,
  Retention:   retentionOptions,
}
backupPolicyOptions := &backupRecovery.BackupPolicy{
  Regular: regularBackupPolicyOptions,
}
createProtectionPolicyOptions := &backupRecovery.CreateProtectionPolicyOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  Name:              core.StringPtr('create-protection-policy-name'),
  BackupPolicy:      backupPolicyOptions,
  Description:       core.StringPtr('<Policy Description>'),
  Version:           core.Int64Ptr(1),
}
result, response, _ := service.CreateProtectionPolicy(createProtectionPolicyOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

ProtectionPolicyResponse

Specifies the details about the Protection Policy

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Returns the Protection Policy details based on provided Policy Id

GET /data-protect/policies/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Policy to return

Get Protection Policy By ID

getProtectionPolicyByIdOptions := &backupRecovery.GetProtectionPolicyByIdOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxx"),
}
result, response, _ := service.GetProtectionPolicyByID(getProtectionPolicyByIdOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ProtectionPolicyResponse

Specifies the details about the Protection Policy

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Specifies the request to update the existing Protection Policy. On successful update, returns the updated policy object

PUT /data-protect/policies/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Policy to update

Request Body

Required*

ProtectionPolicyRequest

Request to update a Protection Policy

Update Protection Policy

runScheduleOptions := &backupRecovery.IncrementalSchedule{
  Unit: core.StringPtr("Minutes"),
  MinuteSchedule: &backupRecovery.MinuteSchedule{
    Frequency: core.Int64Ptr(2),
  },
}
incrementalFullRetentionPolicyOptions := &backupRecovery.IncrementalBackupPolicy{
  Schedule: runScheduleOptions,
}
retentionOptions := &backupRecovery.Retention{
  Unit:     core.StringPtr("Weeks"),
  Duration: core.Int64Ptr(2),
}
regularBackupPolicyOptions := &backupRecovery.RegularBackupPolicy{
  Incremental: incrementalFullRetentionPolicyOptions,
  Retention:   retentionOptions,
}
backupPolicyOptions := &backupRecovery.BackupPolicy{
  Regular: regularBackupPolicyOptions,
}
updateProtectionPolicyByIdOptions := &backupRecovery.UpdateProtectionPolicyOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID:           core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxx"),
  Name:         core.StringPtr("sdk-test-create-protection-policy-1"),
  Description:  core.StringPtr("sdk-test-create-protection-policy-1-update"),
  BackupPolicy: backupPolicyOptions,
}
result, response, _ := service.UpdateProtectionPolicy(updateProtectionPolicyByIdOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

ProtectionPolicyResponse

Specifies the details about the Protection Policy

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Deletes a Protection Policy based on given policy id

DELETE /data-protect/policies/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Policy to delete

Delete Protection Policy

deleteProtectionPolicyOptions := &backupRecovery.DeleteProtectionPolicyOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxx"),
}
response, _ := service.DeleteProtectionPolicy(deleteProtectionPolicyOptions)
fmt.Println(response)

Response

Status Code

204
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

Get the list of Protection Groups

GET /data-protect/protection-groups

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Query Parameters

ids
string[]
Filter by a list of Protection Group ids
names
string[]
Filter by a list of Protection Group names
policyIds
string[]
Filter by Policy ids that are associated with Protection Groups. Only Protection Groups associated with the specified Policy ids, are returned
includeGroupsWithDatalockOnly
boolean
Whether to only return Protection Groups with a datalock
environments
string[]
Filter by environment types such as 'kVMware', 'kView', etc. Only Protection Groups protecting the specified environment types are returned

Allowable values: [kPhysical,kSQL]
isActive
boolean
Filter by Inactive or Active Protection Groups. If not set, all Inactive and Active Protection Groups are returned. If true, only Active Protection Groups are returned. If false, only Inactive Protection Groups are returned. When you create a Protection Group on a Primary Cluster with a replication schedule, the Cluster creates an Inactive copy of the Protection Group on the Remote Cluster. In addition, when an Active and running Protection Group is deactivated, the Protection Group becomes Inactive
isDeleted
boolean
If true, return only Protection Groups that have been deleted but still have Snapshots associated with them. If false, return all Protection Groups except those Protection Groups that have been deleted and still have Snapshots associated with them. A Protection Group that is deleted with all its Snapshots is not returned for either of these cases
isPaused
boolean
Filter by paused or non paused Protection Groups, If not set, all paused and non paused Protection Groups are returned. If true, only paused Protection Groups are returned. If false, only non paused Protection Groups are returned
lastRunLocalBackupStatus
string[]
Filter by last local backup run status.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
lastRunReplicationStatus
string[]
Filter by last remote replication run status.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
lastRunArchivalStatus
string[]
Filter by last cloud archival run status.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
lastRunCloudSpinStatus
string[]
Filter by last cloud spin run status.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
lastRunAnyStatus
string[]
Filter by last any run status.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
isLastRunSlaViolated
boolean
If true, return Protection Groups for which last run SLA was violated
includeLastRunInfo
boolean
If true, the response will include last run info. If it is false or not specified, the last run info won't be returned
pruneExcludedSourceIds
boolean
If true, the response will not include the list of excluded source IDs in groups that contain this field. This can be set to true in order to improve performance if excluded source IDs are not needed by the user
pruneSourceIds
boolean
If true, the response will exclude the list of source IDs within the group specified
useCachedData
boolean
Specifies whether we can serve the GET request from the read replica cache. There is a lag of 15 seconds between the read replica and primary data source
sourceIds
int64[]
Filter by Source ids that are associated with Protection Groups Only Protection Groups associated with the specified Source ids, are returned

Get the list of Protection Groups

getProtectionGroups := &backupRecovery.GetProtectionGroupsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
}
result, response, _ := service.GetProtectionGroups(getProtectionGroups)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ProtectionGroupsResponse

Protection Group response

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Create a Protection Group

POST /data-protect/protection-groups

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

ProtectionGroupRequest

Specifies the parameters to create a Protection Group

Create Protection Group

physicalFileBackupPathOptions := &backupRecovery.PhysicalFileBackupPathParams{
  IncludedPath: core.StringPtr("/"),
}
fileProtectionGroupObjectOptions := &backupRecovery.PhysicalFileProtectionGroupObjectParams{
  ID:        core.Int64Ptr(1),
  Name:      core.StringPtr("file-protection-group-object"),
  FilePaths: []backupRecovery.PhysicalFileBackupPathParams{*physicalFileBackupPathOptions},
}
fileProtectionGroupOptions := &backupRecovery.PhysicalFileProtectionGroupParams{
  Objects: []backupRecovery.PhysicalFileProtectionGroupObjectParams{*fileProtectionGroupObjectOptions},
}
physicalParamsOptions := &backupRecovery.PhysicalProtectionGroupParams{
  ProtectionType:           core.StringPtr("kFile"),
  FileProtectionTypeParams: fileProtectionGroupOptions,
}
createProtectionGroupOptions := &backupRecovery.CreateProtectionGroupOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  Name:            core.StringPtr("create-protection-group-options"),
  PolicyID:        core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xx"),
  Environment:     core.StringPtr("kPhysical"),
  StorageDomainID: core.Int64Ptr(xxxx),
  PhysicalParams:  physicalParamsOptions,
  Priority:        core.StringPtr("kMedium"),
}
getProtectionGroups := &backupRecovery.GetProtectionGroupsOptions{}
result, response, _ := service.CreateProtectionGroup(createProtectionGroupOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

ProtectionGroupResponse

Specifies the parameters which are common between all Protection Group responses

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Returns the Protection Group corresponding to the specified Group id

GET /data-protect/protection-groups/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Group

Query Parameters

includeLastRunInfo
boolean
If true, the response will include last run info. If it is false or not specified, the last run info won't be returned
pruneExcludedSourceIds
boolean
If true, the response will not include the list of excluded source IDs in groups that contain this field. This can be set to true in order to improve performance if excluded source IDs are not needed by the user
pruneSourceIds
boolean
If true, the response will exclude the list of source IDs within the group specified

List Protection group by ID

getProtectionGroupByIdOptions := &backupRecovery.GetProtectionGroupByIdOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxxx"),
}
result, response, _ := service.GetProtectionGroupByID(getProtectionGroupByIdOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ProtectionGroupResponse

Specifies the parameters which are common between all Protection Group responses

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Update the specified Protection Group

PUT /data-protect/protection-groups/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies the id of the Protection Group

Request Body

Required*

ProtectionGroupRequest

Specifies the parameters to update a Protection Group

Update Protection group

physicalFileBackupPathOptions := &backupRecovery.PhysicalFileBackupPathParams{
  IncludedPath: core.StringPtr("/"),
}
fileProtectionGroupObjectOptions := &backupRecovery.PhysicalFileProtectionGroupObjectParams{
  ID:        core.Int64Ptr(1),
  Name:      core.StringPtr("update-file-protection-group-object"),
  FilePaths: []backupRecovery.PhysicalFileBackupPathParams{*physicalFileBackupPathOptions},
}
fileProtectionGroupOptions := &backupRecovery.PhysicalFileProtectionGroupParams{
  Objects: []backupRecovery.PhysicalFileProtectionGroupObjectParams{*fileProtectionGroupObjectOptions},
}
physicalParamsOptions := &backupRecovery.PhysicalProtectionGroupParams{
  ProtectionType:           core.StringPtr("kFile"),
  FileProtectionTypeParams: fileProtectionGroupOptions,
}
updateProtectionGroupOptions := &backupRecovery.UpdateProtectionGroupOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID:              core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxxx"),
  Name:            core.StringPtr("update-protection-group-options"),
  PolicyID:        core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xx"),
  Environment:     core.StringPtr("kPhysical"),
  StorageDomainID: core.Int64Ptr(xxxx),
  PhysicalParams:  physicalParamsOptions,
}
result, response, _ := service.UpdateProtectionGroup(updateProtectionGroupOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

ProtectionGroupResponse

Specifies the parameters which are common between all Protection Group responses

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Returns Success if the Protection Group is deleted

DELETE /data-protect/protection-groups/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Group

Query Parameters

deleteSnapshots
boolean
Specifies if Snapshots generated by the Protection Group should also be deleted when the Protection Group is deleted

Delete Protection Group

deleteProtectionGroupOptions := &backupRecovery.DeleteProtectionGroupOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxxx"),
}
response, _ := service.DeleteProtectionGroup(deleteProtectionGroupOptions)
fmt.Println(response)

Response

Status Code

204
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

Get the runs for a particular Protection Group

GET /data-protect/protection-groups/{id}/runs

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Group

Possible values: Value must match regular expression ^\d+:\d+:\d+$

Query Parameters

runId
string
Specifies the protection run id

Possible values: Value must match regular expression ^\d+:\d+$
startTimeUsecs
int64
Start time for time range filter. Specify the start time as a Unix epoch Timestamp (in microseconds), only runs executing after this time will be returned. By default it is endTimeUsecs minus an hour
endTimeUsecs
int64
End time for time range filter. Specify the end time as a Unix epoch Timestamp (in microseconds), only runs executing before this time will be returned. By default it is current time
runTypes
string[]
Filter by run type. Only protection run matching the specified types will be returned

Allowable values: [kAll,kHydrateCDP,kSystem,kStorageArraySnapshot,kIncremental,kFull,kLog]
Possible values: contains only unique items
includeObjectDetails
boolean
Specifies if the result includes the object details for each protection run. If set to true, details of the protected object will be returned. If set to false or not specified, details will not be returned
localBackupRunStatus
string[]
Specifies a list of local backup status, runs matching the status will be returned.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
replicationRunStatus
string[]
Specifies a list of replication status, runs matching the status will be returned.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
archivalRunStatus
string[]
Specifies a list of archival status, runs matching the status will be returned.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
cloudSpinRunStatus
string[]
Specifies a list of cloud spin status, runs matching the status will be returned.
'Running' indicates that the run is still running.
'Canceled' indicates that the run has been canceled.
'Canceling' indicates that the run is in the process of being canceled.
'Failed' indicates that the run has failed.
'Missed' indicates that the run was unable to take place at the scheduled time because the previous run was still happening.
'Succeeded' indicates that the run has finished successfully.
'SucceededWithWarning' indicates that the run finished successfully, but there were some warning messages.
'Paused' indicates that the ongoing run has been paused.
'Skipped' indicates that the run was skipped

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,Paused]
numRuns
int64
Specifies the max number of runs. If not specified, at most 100 runs will be returned
excludeNonRestorableRuns
boolean
Specifies whether to exclude non restorable runs. Run is treated restorable only if there is atleast one object snapshot (which may be either a local or an archival snapshot) which is not deleted or expired. Default value is false

Default: false
runTags
string[]
Specifies a list of tags for protection runs. If this is specified, only the runs which match these tags will be returned
useCachedData
boolean
Specifies whether we can serve the GET request from the read replica cache. There is a lag of 15 seconds between the read replica and primary data source
filterByEndTime
boolean
If true, the runs with backup end time within the specified time range will be returned. Otherwise, the runs with start time in the time range are returned
snapshotTargetTypes
string[]
Specifies the snapshot's target type which should be filtered

Allowable values: [Local,Archival,RpaasArchival,StorageArraySnapshot,Remote]
Possible values: contains only unique items
onlyReturnSuccessfulCopyRun
boolean
only successful copyruns are returned
filterByCopyTaskEndTime
boolean
If true, then the details of the runs for which any copyTask completed in the given timerange will be returned. Only one of filterByEndTime and filterByCopyTaskEndTime can be set

Get Protection group Runs

getProtectionGroupRunsOptions := &backupRecovery.GetProtectionGroupRunsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxxx"),
}
result, response, _ := service.GetProtectionGroupRuns(getProtectionGroupRunsOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ProtectionGroupRunsResponse

Protection runs

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Update runs for a particular Protection Group. A user can perform the following actions: 1. Extend or reduce retention of a local, replication and archival snapshots. 2. Can perform resync operation on failed copy snapshots attempts in this Run. 3. Add new replication and archival snapshot targets to the Run. 4. Add or remove legal hold on the snapshots. Only a user with DSO role can perform this operation. 5. Delete the snapshots that were created as a part of this Run. 6. Apply datalock on existing snapshots where a user cannot manually delete snapshots before the expiry time.

PUT /data-protect/protection-groups/{id}/runs

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Group

Request Body

Required*

UpdateProtectionGroupRunRequest

Specifies the parameters to update a Protection Group Run

Update Protection group Run

localSnapshotConfigOptions := &backupRecovery.UpdateLocalSnapshotConfig{
  EnableLegalHold: core.BoolPtr(false),
}
updateProtectionGroupRunParamsOptions := &backupRecovery.UpdateProtectionGroupRunParams{
  RunID:               core.StringPtr("xxxxx:xxxxxxxxxxxxxxxx"),
  LocalSnapshotConfig: localSnapshotConfigOptions,
}
updateProectionGroupRunOptions := &backupRecovery.UpdateProtectionGroupRunOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID:                             core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxxx"),
  UpdateProtectionGroupRunParams: []backupRecovery.UpdateProtectionGroupRunParams{*updateProtectionGroupRunParamsOptions},
}
result, response, _ := service.UpdateProtectionGroupRun(updateProectionGroupRunOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

UpdateProtectionGroupRunResponse

Specifies the response of update Protection Group Runs request

Status Code

207
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Create a new protection run. This can be used to start a run for a Protection Group on demand, ignoring the schedule and retention specified in the protection policy

POST /data-protect/protection-groups/{id}/runs

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Group

Request Body

Required*

ProtectionGroupRunRequest

Specifies the parameters to start a protection run

Create Protection Group Run

createProtectionGroupRunOptions := &backupRecovery.CreateProtectionGroupRunOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID:      core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxxx"),
  RunType: core.StringPtr("kRegular"),
}
result, response, _ := service.CreateProtectionGroupRun(createProtectionGroupRunOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

CreateProtectionGroupRunResponse

Specifies the response for create a protection run. On success, the system will accept the request and return the Protection Group id for which the run is supposed to start. The actual run may start at a later time if the system is busy. Consumers must query the Protection Group to see the run

Status Code

202
Accepted
default
Error

No Sample Response

This method does not specify any sample responses.

Perform various actions on a Protection Group run

POST /data-protect/protection-groups/{id}/runs/actions

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies a unique id of the Protection Group

Request Body

Required*

PerformActionOnProtectionGroupRunRequest

Specifies the parameters to perform an action on a protection run

Perform Action on Protection Group Run

pauseProtectionRunActionParamsOptions := &backupRecovery.PauseProtectionRunActionParams{
  RunID: core.StringPtr("xxxxx:xxxxxxxxxxxxxxxx"),
}
performActionOnProtectionGroupRunOptions := &backupRecovery.PerformActionOnProtectionGroupRunOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID:          core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxxxx"),
  Action:      core.StringPtr("Pause"),
  PauseParams: []backupRecovery.PauseProtectionRunActionParams{*pauseProtectionRunActionParamsOptions},
}
result, response, _ := service.PerformActionOnProtectionGroupRun(performActionOnProtectionGroupRunOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

PerformRunActionResponse

Specifies the response of the performed run action

Status Code

202
Accepted
default
Error

No Sample Response

This method does not specify any sample responses.

Lists the Recoveries

GET /data-protect/recoveries

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Query Parameters

ids
string[]
Filter Recoveries for given ids

Possible values: Value must match regular expression ^\d+:\d+:\d+$
returnOnlyChildRecoveries
boolean
Returns only child recoveries if passed as true. This filter should always be used along with 'ids' filter.
startTimeUsecs
int64
Returns the recoveries which are started after the specific time This value should be in Unix timestamp epoch in microseconds
endTimeUsecs
int64
Returns the recoveries which are started before the specific time. This value should be in Unix timestamp epoch in microseconds
snapshotTargetType
string[]
Specifies the snapshot's target type from which recovery has been performed

Allowable values: [Local,Archival,RpaasArchival,StorageArraySnapshot,Remote]
Possible values: contains only unique items
archivalTargetType
string[]
Specifies the snapshot's archival target type from which recovery has been performed. This parameter applies only if 'snapshotTargetType' is 'Archival'

Allowable values: [Tape,Cloud,Nas]
Possible values: contains only unique items
snapshotEnvironments
string[]
Specifies the list of snapshot environment types to filter Recoveries. If empty, Recoveries related to all environments will be returned

Allowable values: [kPhysical,kSQL]
Possible values: contains only unique items
status
string[]
Specifies the list of run status to filter Recoveries. If empty, Recoveries with all run status will be returned

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,LegalHold]
Possible values: contains only unique items
recoveryActions
string[]
Specifies the list of recovery actions to filter Recoveries. If empty, Recoveries related to all actions will be returned

Allowable values: [RecoverVMs,RecoverFiles,InstantVolumeMount,RecoverVmDisks,RecoverVApps,RecoverVAppTemplates,UptierSnapshot,RecoverRDS,RecoverAurora,RecoverS3Buckets,RecoverRDSPostgres,RecoverAzureSQL,RecoverApps,CloneApps,RecoverNasVolume,RecoverPhysicalVolumes,RecoverSystem,RecoverExchangeDbs,CloneAppView,RecoverSanVolumes,RecoverSanGroup,RecoverMailbox,RecoverOneDrive,RecoverSharePoint,RecoverPublicFolders,RecoverMsGroup,RecoverMsTeam,ConvertToPst,DownloadChats,RecoverMailboxCSM,RecoverOneDriveCSM,RecoverSharePointCSM,RecoverNamespaces,RecoverObjects,RecoverSfdcObjects,RecoverSfdcOrg,RecoverSfdcRecords,DownloadFilesAndFolders,CloneVMs,CloneView,CloneRefreshApp,CloneVMsToView,ConvertAndDeployVMs,DeployVMs]

Get Recoveries

getRecoveriesOptions := &backupRecovery.GetRecoveriesOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
}
result, response, _ := service.GetRecoveries(getRecoveriesOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

RecoveriesResponse

Specifies list of Recoveries

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Performs a Recovery

POST /data-protect/recoveries

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Request Body

Required*

RecoveryRequestParams

Specifies the parameters to create a Recovery

Create a Recovery

commonRecoveryObjectSnapshotParams := &backupRecovery.CommonRecoverObjectSnapshotParams{
  SnapshotID: core.StringPtr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
}
physicalTargetParamsForRecoverVolumeMountTarget := &backupRecovery.PhysicalTargetParamsForRecoverVolumeMountTarget{
  ID:   core.Int64Ptr(1),
  Name: core.StringPtr("physical-target-name"),
}
recoverVolumeMapping := &backupRecovery.RecoverVolumeMapping{
  SourceVolumeGuid:      core.StringPtr("recovery-volume-mapping-source-name"),
  DestinationVolumeGuid: core.StringPtr("recovery-volume-mapping-destination-name"),
}
recoverPhysicalVolumeParamsPhysicalTargetParams := &backupRecovery.RecoverPhysicalVolumeParamsPhysicalTargetParams{
  MountTarget:   physicalTargetParamsForRecoverVolumeMountTarget,
  VolumeMapping: []backupRecovery.RecoverVolumeMapping{*recoverVolumeMapping},
}
recoverPhysicalParamsRecoverVolumeParams := &backupRecovery.RecoverPhysicalParamsRecoverVolumeParams{
  TargetEnvironment:    core.StringPtr("kPhysical"),
  PhysicalTargetParams: recoverPhysicalVolumeParamsPhysicalTargetParams,
}
recoveryPhysicalParams := &backupRecovery.RecoverPhysicalParams{
  Objects:             []backupRecovery.CommonRecoverObjectSnapshotParams{*commonRecoveryObjectSnapshotParams},
  RecoveryAction:      core.StringPtr("RecoverPhysicalVolumes"),
  RecoverVolumeParams: recoverPhysicalParamsRecoverVolumeParams,
}
createRecoveryOptions := &backupRecovery.CreateRecoveryOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  Name:                core.StringPtr("create-recovery-options-name"),
  SnapshotEnvironment: core.StringPtr("kPhysical"),
  PhysicalParams:      recoveryPhysicalParams,
}
result, response, _ := service.CreateRecovery(createRecoveryOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

Recovery

Specifies the common response parameters to create a Recovery

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Creates a download files and folders recovery

POST /data-protect/recoveries/download-files-folders

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

DownloadFilesAndFoldersRequestParams

Specifies the parameters to create a download files and folder recovery

Create Download Files and Folders Recovery

commonRecoveryObjectSnapshotParams := &backupRecovery.CommonRecoverObjectSnapshotParams{
  SnapshotID: core.StringPtr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
}
filesAndFoldersObjectOptions := &backupRecovery.FilesAndFoldersObject{
  AbsolutePath: core.StringPtr("/"),
}
createDownloadFilesAndFoldersRecoveryOptions := &backupRecovery.CreateDownloadFilesAndFoldersRecoveryOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  Name:            core.StringPtr("create-download-files-and-folders-recovery-name"),
  Object:          commonRecoveryObjectSnapshotParams,
  FilesAndFolders: []backupRecovery.FilesAndFoldersObject{*filesAndFoldersObjectOptions},
}
result, response, _ := service.CreateDownloadFilesAndFoldersRecovery(createDownloadFilesAndFoldersRecoveryOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

Recovery

Specifies the common response parameters to create a Recovery

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Get Recovery for a given id

GET /data-protect/recoveries/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies the id of a Recovery

Possible values: Value must match regular expression ^\d+:\d+:\d+$

Get Recovery by ID

getRecoveryByIdOptions := &backupRecovery.GetRecoveryByIdOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxx"),
}
result, response, _ := service.GetRecoveryByID(getRecoveryByIdOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

Recovery

Specifies the common response parameters to create a Recovery

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Download files from the given download file recovery

GET /data-protect/recoveries/{id}/download-files

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
string
Specifies the id of a Recovery

Possible values: Value must match regular expression ^\d+:\d+:\d+$

Query Parameters

startOffset
int64
Specifies the start offset of file chunk to be downloaded
length
int64
Specifies the length of bytes to download. This can not be greater than 8MB (8388608 byets)
fileType
string
Specifies the downloaded type, i.e: error, success_files_list
sourceName
string
Specifies the name of the source on which restore is done
startTime
string
Specifies the start time of restore task
includeTenants
boolean
Specifies if objects of all the organizations under the hierarchy of the logged in user's organization should be returned

Download Files from Recovery

downloadFilesFromRecoveryOptions := &backupRecovery.DownloadFilesFromRecoveryOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.StringPtr("xxxxxxxxxxxxxxxx:xxxxxxxxxxxxx:xxx"),
}
response, _ := service.DownloadFilesFromRecovery(downloadFilesFromRecoveryOptions)
fmt.Println(response)

Response

Status Code

200
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

List Restore Points i.e. returns the snapshots in in a given time range

POST /data-protect/snapshots/restore-points

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

GetRestorePointsInTimeRangeParams

Specifies the parameters to search for indexed objects

Get Restore Points In Time Range

getRestorePointsInTimeRangeOptions := &backupRecovery.GetRestorePointsInTimeRangeOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  StartTimeUsecs: core.Int64Ptr(1),
  EndTimeUsecs: core.Int64Ptr(10),
  ProtectionGroupIds: []string{"protection-group-id-1"}
}
result, response, _ := service.GetRestorePointsInTimeRange(getRestorePointsInTimeRangeOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

GetRestorePointsInTimeRangeResponse

Specifies the model for the response returned by RestorePointsForTimeRange API

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Download an indexed file from a snapshot

GET /data-protect/snapshots/{snapshotsId}/download-file

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

snapshotsId
Required*
string
Specifies the snapshot id to download from

Query Parameters

filePath
string
Specifies the path to the file to download. If no path is specified and snapshot environment is kVMWare, VMX file for VMware will be downloaded. For other snapshot environments, this field must be specified
nvramFile
boolean
Specifies if NVRAM file for VMware should be downloaded
retryAttempt
int64
Specifies the number of attempts the protection run took to create this file
startOffset
int64
Specifies the start offset of file chunk to be downloaded
length
int64
Specifies the length of bytes to download. This can not be greater than 8MB (8388608 byets)

Download Indexed File

downloadIndexedFileOptions := &backupRecovery.DownloadIndexedFileOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  SnapshotsID: core.StringPtr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
  FilePath:    core.StringPtr("./"),
}
response, _ := service.DownloadIndexedFile(downloadIndexedFileOptions)
fmt.Println(response)
Copy to clipboard

Response

Status Code

200
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

List all the indexed objects like files and folders, emails, mailboxes etc., that match the specified search and filter criteria from protected objects

POST /data-protect/search/indexed-objects

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

SearchIndexedObjectsRequest

Specifies the parameters to search for indexed objects

Search Indexed Objects

searchFileRequestParams := &backupRecovery.SearchFileRequestParams{
  SearchString: core.StringPtr("search-string-name"),
}
searchIndexedObjectsOptions := &backupRecovery.SearchIndexedObjectsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ObjectType: core.StringPtr("Files"),
  FileParams: searchFileRequestParams,
}
result, response, _ := service.SearchIndexedObjects(searchIndexedObjectsOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

SearchIndexedObjectsResponse

Specifies the common search indexed objects response params

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

List objects

GET /data-protect/search/objects

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Query Parameters

searchString
string
Specifies the search string to filter the objects. This search string will be applicable for objectnames. User can specify a wildcard character '' as a suffix to a string where all object names are matched with the prefix string. For example, if vm1 and vm2 are the names of objects, user can specify vm to list the objects. If not specified, then all the objects will be returned which will match other filtering criteria
environments
string[]
Specifies the environment type to filter objects

Allowable values: [kPhysical,kSQL]
Possible values: contains only unique items
protectionTypes
string[]
Specifies the protection type to filter objects

Allowable values: [kAgent,kNative,kSnapshotManager,kRDSSnapshotManager,kAuroraSnapshotManager,kAwsS3,kAwsRDSPostgresBackup,kAwsAuroraPostgres,kAwsRDSPostgres,kAzureSQL,kFile,kVolume]
Possible values: contains only unique items
protectionGroupIds
string[]
Specifies a list of Protection Group ids to filter the objects. If specified, the objects protected by specified Protection Group ids will be returned
objectIds
int64[]
Specifies a list of Object ids to filter
osTypes
string[]
Specifies the operating system types to filter objects on

Allowable values: [kLinux,kWindows]
sourceIds
int64[]
Specifies a list of Protection Source object ids to filter the objects. If specified, the object which are present in those Sources will be returned
sourceUuids
string[]
Specifies a list of Protection Source object uuids to filter the objects. If specified, the object which are present in those Sources will be returned
isProtected
boolean
Specifies the protection status of objects. If set to true, only protected objects will be returned. If set to false, only unprotected objects will be returned. If not specified, all objects will be returned
isDeleted
boolean
If set to true, then objects which are deleted on atleast one cluster will be returned. If not set or set to false then objects which are registered on atleast one cluster are returned
lastRunStatusList
string[]
Specifies a list of status of the object's last protection run Only objects with last run status of these will be returned

Allowable values: [Accepted,Running,Canceled,Canceling,Failed,Missed,Succeeded,SucceededWithWarning,OnHold,Finalizing,Skipped,LegalHold]
clusterIdentifiers
string[]
Specifies the list of cluster identifiers. Format is clusterId:clusterIncarnationId Only records from clusters having these identifiers will be returned
includeDeletedObjects
boolean
Specifies whether to include deleted objects in response. These objects can't be protected but can be recovered. This field is deprecated
paginationCookie
string
Specifies the pagination cookie with which subsequent parts of the response can be fetched
count
int32
Specifies the number of objects to be fetched for the specified pagination cookie
mustHaveTagIds
string[]
Specifies tags which must be all present in the document

Possible values: contains only unique items, Value must match regular expression ^\d+:\d+:[A-Z0-9-]+$
mightHaveTagIds
string[]
Specifies list of tags, one or more of which might be present in the document. These are OR'ed together and the resulting criteria AND'ed with the rest of the query

Possible values: contains only unique items, Value must match regular expression ^\d+:\d+:[A-Z0-9-]+$
mustHaveSnapshotTagIds
string[]
Specifies snapshot tags which must be all present in the document

Possible values: contains only unique items, Value must match regular expression ^\d+:\d+:[A-Z0-9-]+$
mightHaveSnapshotTagIds
string[]
Specifies list of snapshot tags, one or more of which might be present in the document. These are OR'ed together and the resulting criteria AND'ed with the rest of the query

Possible values: contains only unique items, Value must match regular expression ^\d+:\d+:[A-Z0-9-]+$
tagSearchName
string
Specifies the tag name to filter the tagged objects and snapshots User can specify a wildcard character '*' as a suffix to a string where all object's tag names are matched with the prefix string
tagNames
string[]
Specifies the tag names to filter the tagged objects and snapshots
tagTypes
string[]
Specifies the tag names to filter the tagged objects and snapshots

Allowable values: [System,Custom,ThirdParty]
tagCategories
string[]
Specifies the tag category to filter the objects and snapshots

Allowable values: [Security]
tagSubCategories
string[]
Specifies the tag subcategory to filter the objects and snapshots

Allowable values: [Classification,Threats,Anomalies,Dspm]
includeHeliosTagInfoForObjects
boolean
pecifies whether to include helios tags information for objects in response. Default value is false
externalFilters
string[]
Specifies the key-value pairs to filtering the results for the search. Each filter is of the form 'key:value'. The filter 'externalFilters:k1:v1&externalFilters:k2:v2&externalFilters:k2:v3' returns the documents where each document will match the query (k1=v1) AND (k2=v2 OR k2 = v3). Allowed keys: - vmBiosUuid - graphUuid - arn - instanceId - bucketName - azureId

Search Objects

searchOjectsOptions := &backupRecovery.SearchObjectsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  SearchString: core.StringPtr("*"),
}
result, response, _ := service.SearchObjects(searchOjectsOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ObjectsSearchResponseBody

Specifies the Objects search result

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

List protected objects and corresponding detail information from registered sources filtered by specified query parameters. If no search pattern or filter parameters are specified, all protected objects currently found are returned

GET /data-protect/search/protected-objects

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Query Parameters

searchString
string
Specifies the search string to filter the objects. This search string will be applicable for objectnames and Protection Group names. User can specify a wildcard character '' as a suffix to a string where all object and their Protection Group names are matched with the prefix string. For example, if vm1 and vm2 are the names of objects, user can specify vm to list the objects. If not specified, then all the objects with Protection Groups will be returned which will match other filtering criteria
environments
string[]
Specifies the environment type to filter objects

Allowable values: [kPhysical,kSQL]
Possible values: contains only unique items
snapshotActions
string[]
Specifies a list of recovery actions. Only snapshots that applies to these actions will be returned

Allowable values: [RecoverVMs,RecoverFiles,InstantVolumeMount,RecoverVmDisks,MountVolumes,RecoverVApps,RecoverRDS,RecoverAurora,RecoverS3Buckets,RecoverApps,RecoverNasVolume,RecoverPhysicalVolumes,RecoverSystem,RecoverSanVolumes,RecoverNamespaces,RecoverObjects,DownloadFilesAndFolders,RecoverPublicFolders,RecoverVAppTemplates,RecoverMailbox,RecoverOneDrive,RecoverMsTeam,RecoverMsGroup,RecoverSharePoint,ConvertToPst,RecoverSfdcRecords,RecoverAzureSQL,DownloadChats,RecoverRDSPostgres,RecoverMailboxCSM,RecoverOneDriveCSM,RecoverSharePointCSM]
Possible values: contains only unique items
objectActionKey
string
Filter by ObjectActionKey, which uniquely represents protection of an object. An object can be protected in multiple ways but atmost once for a given combination of ObjectActionKey. When specified, latest snapshot info matching the objectActionKey is for corresponding object

Allowable values: [kPhysical,kSQL]
protectionGroupIds
string[]
Specifies a list of Protection Group ids to filter the objects. If specified, the objects protected by specified Protection Group ids will be returned
objectIds
int64[]
Specifies a list of Object ids to filter
subResultSize
int32
Specifies the size of objects to be fetched for a single subresult
filterSnapshotFromUsecs
int64
Specifies the timestamp in Unix time epoch in microseconds to filter the objects if the Object has a successful snapshot after this value
filterSnapshotToUsecs
int64
Specifies the timestamp in Unix time epoch in microseconds to filter the objects if the Object has a successful snapshot before this value
osTypes
string[]
Specifies the operating system types to filter objects on

Allowable values: [kLinux,kWindows]
sourceIds
int64[]
Specifies a list of Protection Source object ids to filter the objects. If specified, the object which are present in those Sources will be returned
runInstanceIds
int64[]
Specifies a list of run instance ids. If specified only objects belonging to the provided run id will be retunrned
cdpProtectedOnly
boolean
Specifies whether to only return the CDP protected objects
useCachedData
boolean
Specifies whether we can serve the GET request to the read replica cache cache. There is a lag of 15 seconds between the read replica and primary data source

Search Objects

searchProtectedObjectsOptions := &backupRecovery.SearchProtectedObjectsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  SearchString: core.StringPtr("*"),
}
result, response, _ := service.SearchProtectedObjects(searchProtectedObjectsOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ProtectedObjectsSearchResponse

Specifies the Protected Objects search result

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Get the list of Protection Source registrations

GET /data-protect/sources/registrations

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Query Parameters

ids
integer[]
Ids specifies the list of source registration ids to return. If left empty, every source registration will be returned by default
includeSourceCredentials
boolean
If true, the encrypted crednetial for the registered sources will be included. Credential is first encrypted with internal key and then reencrypted with user supplied encryption key
encryptionKey
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
useCachedData
boolean
Specifies whether we can serve the GET request from the read replica cache. There is a lag of 15 seconds between the read replica and primary data source
includeExternalMetadata
boolean
If true, the external entity metadata like maintenance mode config for the registered sources will be included
ignoreTenantMigrationInProgressCheck
boolean
If true, tenant migration check will be ignored

Get Source Registrations

getSourceRegistrationOptions := &backupRecovery.GetSourceRegistrationsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
}
result, response, _ := service.GetSourceRegistrations(getSourceRegistrationOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

SourceRegistrations

Protection Source Registrations

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Register a Protection Source

POST /data-protect/sources/registrations

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Request Body

Required*

SourceRegistrationRequestParams

Specifies the parameters to register a Protection Source

Register a Protection Source

physicalParamsOptions := &backupRecovery.PhysicalParams{
  Endpoint:     core.StringPtr("xxx.xx.xx.xx"),
  HostType:     core.StringPtr("kWindows"),
  PhysicalType: core.StringPtr("kHost"),
  Applications: []string{"kSQL"},
}
registerSourceRegistrationOptions := &backupRecovery.RegisterProtectionSourceOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  Environment:     core.StringPtr("kPhysical"),
  Name:            core.StringPtr("register-protection-source-name"),
  PhysicalParams:  physicalParamsOptions,
}
result, response, _ := service.RegisterProtectionSource(registerSourceRegistrationOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

SourceRegistrationReponseParams

Specifies the parameters which are common between all Protection Source registrations

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Get a Protection Source registration

GET /data-protect/sources/registrations/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified
requestInitiatorType
string
Specifies the type of request from UI, which is used for services like magneto to determine the priority of requests

Allowable values: [UIUser,UIAuto,Helios]

Path Parameters

id
Required*
int64
Specifies the id of the Protection Source registration

Get Protection Source Registration By ID

getProtectionSourceByIdOptions := &backupRecovery.GetProtectionSourceRegistrationOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.Int64Ptr(1),
}
result, response, _ := service.GetProtectionSourceRegistration(getProtectionSourceByIdOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

SourceRegistrationReponseParams

Specifies the parameters which are common between all Protection Source registrations

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Update Protection Source registration

PUT /data-protect/sources/registrations/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
int64
Specifies the id of the Protection Source registration

Request Body

Required*

SourceRegistrationUpdateRequestParams

Specifies the parameters to update the registration

Update Protection Source by ID

physicalParamsOptions := &backupRecovery.PhysicalParams{
  Endpoint:     core.StringPtr("xxx.xx.xx.xx"),
  HostType:     core.StringPtr("kLinux"),
  PhysicalType: core.StringPtr("kHost"),
  Applications: []string{"kSQL"},
}
updateSourceRegistrationOptions := &backupRecovery.UpdateProtectionSourceRegistrationOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID:              core.Int64Ptr(1),
  Environment:     core.StringPtr("kPhysical"),
  Name:            core.StringPtr("update-protection-source-name"),
  PhysicalParams:  physicalParamsOptions,
}
result, response, _ := service.UpdateProtectionSourceRegistration(updateSourceRegistrationOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

SourceRegistrationReponseParams

Specifies the parameters which are common between all Protection Source registrations

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Patches a Protection Source

PATCH /data-protect/sources/registrations/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
int64
Specifies the id of the Protection Source registration

Request Body

Required*

SourceRegistrationPatchRequestParams

Specifies the parameters to partially update the registration

Patch Protection Source

patchDataSourceConnectionOptions := &backupRecovery.PatchDataSourceConnectionOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ConnectionID:   core.StringPtr("connection-id"),
  ConnectionName: core.StringPtr("connection-name"),
}
result, response, _ := service.PatchDataSourceConnection(patchDataSourceConnectionOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

SourceRegistrationReponseParams

Specifies the parameters which are common between all Protection Source registrations

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Delete Protection Source Registration

DELETE /data-protect/sources/registrations/{id}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
int64
Specifies the ID of the Protection Source Registration

Delete Protection Source Registration

deleteProtectionSourceOptions := &backupRecovery.DeleteProtectionSourceRegistrationOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.Int64Ptr(1),
}
response, _ := service.DeleteProtectionSourceRegistration(deleteProtectionSourceOptions)
fmt.Println(response)

Response

Status Code

204
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

Refresh a Protection Source

POST /data-protect/sources/{id}/refresh

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

id
Required*
int64
Specifies the id of the Protection Source

Refresh Protection Source

refreshProtectionSourceByIdOptions := &backupRecovery.RefreshProtectionSourceByIdOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ID: core.Int64Ptr(1),
}
response, _ := service.RefreshProtectionSourceByID(refreshProtectionSourceByIdOptions)
fmt.Println(response)

Response

Status Code

204
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

Gets all specified data-source connections

GET /data-source-connections

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Query Parameters

connectionIds
string[]
Specifies the unique IDs of the connections which are to be fetched
connectionNames
string[]
Specifies the names of the connections which are to be fetched

Get Data Source Connections

getDataSourceConnectionsOptions := &backupRecovery.GetDataSourceConnectionsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
}
result, response, _ := service.GetDataSourceConnections(getDataSourceConnectionsOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

DataSourceConnectionList

Specifies a list of data-source connections

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Creates a data-source connection which can be used to register and protect sources, to access filer services, etc

POST /data-source-connections

Request

Custom Headers

X-IBM-Tenant-Id
string
Id of the tenant accessing the cluster

Request Body

Required*

CreateDataSourceConnectionRequest

Specifies the request parameters to create a connection

Create a Data Source Connection

createDataSourceConnectionOptions := &backupRecovery.CreateDataSourceConnectionOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ConnectionName: core.StringPtr("data-connection-name"),
}
result, response, _ := service.CreateDataSourceConnection(createDataSourceConnectionOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

DataSourceConnection

Specifies all the properties of the data-source connection. A connection is specified by an ID that's guaranteed to be unique. A connection is associated with exactly one tenant. A connection can be thought of as a subset of its tenant's connectors and can contain 0 or more connectors within it. A connector can only be associated with one connection at max at a given time

Status Code

201
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Delete a data-source connection using its ID. After deleting a connection, any connectors within it won't be able to connect to the cluster A connection should only be deleted after ensuring that no sources are using it

DELETE /data-source-connections/{connectionId}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

connectionId
Required*
string
Specifies the ID of the connection, connectors belonging to which are to be fetched

Delete Data Source Connection

deleteDataSourceConnectionOptions := &backupRecovery.DeleteDataSourceConnectionOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ConnectionID: core.StringPtr("connection-id"),
}
response, _ := service.DeleteDataSourceConnection(deleteDataSourceConnectionOptions)
fmt.Println(response)

Response

Status Code

204
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

Patch the data-source connection specified by the ID in the request path

PATCH /data-source-connections/{connectionId}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

connectionId
Required*
string
Specifies the ID of the connection, connectors belonging to which are to be fetched

Request Body

Required*

PatchDataSourceConnectionRequest

Specifies the connection resource with the properties that can be patched

Patch Data Source Connection

patchDataSourceConnectionOptions := &backupRecovery.PatchDataSourceConnectionOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ConnectionID:   core.StringPtr("connection-id"),
  ConnectionName: core.StringPtr("connection-name"),
}
result, response, _ := service.PatchDataSourceConnection(patchDataSourceConnectionOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

DataSourceConnection

Specifies all the properties of the data-source connection. A connection is specified by an ID that's guaranteed to be unique. A connection is associated with exactly one tenant. A connection can be thought of as a subset of its tenant's connectors and can contain 0 or more connectors within it. A connector can only be associated with one connection at max at a given time

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Generate a token to register connectors against the data-source connection specified by the ID in the request path. The same token can be used to register multiple connectors as long as the token is valid. Once the token expires, typically in a day, this API can be hit again to generate another token

POST /data-source-connections/{connectionId}/registrationToken

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

connectionId
Required*
string
Specifies the ID of the connection, connectors belonging to which are to be fetched

Generate Data Source Connection Registration Token

generateDataSourceConnectionRegistrationTokenOptions := &backupRecovery.GenerateDataSourceConnectionRegistrationTokenOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ConnectionID: core.StringPtr("connection-id"),
}
result, response, _ := service.GenerateDataSourceConnectionRegistrationToken(generateDataSourceConnectionRegistrationTokenOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

string

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Gets all specified data-source connectors

GET /data-source-connectors

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Query Parameters

connectorIds
string[]
Specifies the unique IDs of the connectors which are to be fetched
connectorNames
string[]
Specifies the names of the connectors which are to be fetched
connectionId
string
Specifies the ID of the connection, connectors belonging to which are to be fetched

Get Data Source Connector

getDataSourceConnectorOptions := &backupRecovery.GetDataSourceConnectorsOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  TenantID:     core.StringPtr("tenantId/"),
  ConnectionID: core.StringPtr("xxxxxxxxxxxxxxxxxxx"),
}
result, response, _ := service.GetDataSourceConnectors(getDataSourceConnectorOptions)
fmt.Println(result)
fmt.Println(response)
Copy to clipboard

Response

Response Body

DataSourceConnectorList

Specifies a list of data-source connectors

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Get information about the available connectors

GET /data-source-connectors/metadata

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Get Connector Metadata

getConnectorMetadataOptions := &backupRecovery.GetConnectorMetadataOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
}
result, response, _ := service.GetConnectorMetadata(getConnectorMetadataOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

ConnectorMetadata

Specifies information about the connector

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Delete the data-source connector specified by the ID in the request path

DELETE /data-source-connectors/{connectorId}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

connectorId
Required*
string
Specifies the unique ID of the connector which is to be deleted

Delete Data Source Connector

deleteDataSourceConnectorOptions := &backupRecovery.DeleteDataSourceConnectorOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ConnectorID: core.StringPtr("connector-id"),
}
response, _ := service.DeleteDataSourceConnector(deleteDataSourceConnectorOptions)
fmt.Println(response)

Response

Status Code

204
No content available
default
Error

No Sample Response

This method does not specify any sample responses.

Patch the data-source connector specified by the ID in the request path

PATCH /data-source-connectors/{connectorId}

Request

Custom Headers

X-IBM-Tenant-Id
Required*
string
Specifies the key to be used to encrypt the source credential If includeSourceCredentials is set to true this key must be specified

Path Parameters

connectorId
Required*
string
Specifies the unique ID of the connector which is to be deleted

Request Body

Required*

PatchDataSourceConnectorRequest

Specifies the properties of a data-source connector to patch

Patch Data Source Connector

patchDataSourceConnectorOptions := &backupRecovery.PatchDataSourceConnectorOptions{
  XIBMTenantID: core.StringPtr("xxxxxxxxxx/"),
  ConnectorID: core.StringPtr("connector-id"),
}
result, response, _ := service.PatchDataSourceConnector(patchDataSourceConnectorOptions)
fmt.Println(result)
fmt.Println(response)

Response

Response Body

DataSourceConnector

Specifies all the properties of the data-source connector. A connector is uniquely identified by a 'connectorId' for a given tenant. A connector resource is created internally by the system when a connector is registered with the cluster and thus, a POST API doesn't exist and isn't needed for creating a connector resource. An active connector is always associated with a data-source connection belonging to its tenant. A connector can never be associated with more than one connection/tenant/cluster at a given time. A connector also has a name which can be updated by the user. Names of connectors for a tenant or across tenants needn't be unique. Also, a connector constituent can optionally have two actively used NICs (dual-homed connectors)

Status Code

200
Success
default
Error

No Sample Response

This method does not specify any sample responses.

Introduction

Methods

Download agent

Request

Custom Headers

X-IBM-Tenant-Id

Request Body

platform

linuxParams

Response

Response Body

Status Code

200

default

No Sample Response

Get upgrade tasks

Request

Custom Headers

X-IBM-Tenant-Id

Query Parameters

ids

Response

Response Body

tasks

Status Code

200

default

No Sample Response

Create an upgrade task

Request

Custom Headers

X-IBM-Tenant-Id

Request Body

agentIDs

description

name

retryTaskId

scheduleEndTimeUsecs

scheduleTimeUsecs

Response

Response Body

agentIDs

agents

clusterVersion

description

endTimeUsecs

error

id

isRetryable

name

retriedTaskID

scheduleEndTimeUsecs

scheduleTimeUsecs

startTimeUsecs

status

type

Status Code

201

default

No Sample Response

List the snapshots for a given object

Request

Custom Headers

X-IBM-Tenant-Id

Path Parameters

id

Query Parameters

fromTimeUsecs

toTimeUsecs

runStartFromTimeUsecs

runStartToTimeUsecs

snapshotActions

runTypes

protectionGroupIds

runInstanceIds

regionIds

objectActionKeys

Response

Response Body

snapshots