Class: Aws::Backup::Client

Inherits:
Seahorse::Client::Base show all
Includes:
ClientStubs
Defined in:
gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb

Overview

An API client for Backup. To construct a client, you need to configure a :region and :credentials.

client = Aws::Backup::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the developer guide.

See #initialize for a full list of supported configuration options.

Instance Attribute Summary

Attributes inherited from Seahorse::Client::Base

#config, #handlers

API Operations collapse

Instance Method Summary collapse

Methods included from ClientStubs

#api_requests, #stub_data, #stub_responses

Methods inherited from Seahorse::Client::Base

add_plugin, api, clear_plugins, define, new, #operation_names, plugins, remove_plugin, set_api, set_plugins

Methods included from Seahorse::Client::HandlerBuilder

#handle, #handle_request, #handle_response

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

    A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials. This can be an instance of any one of the following classes:

    • Aws::Credentials - Used for configuring static, non-refreshing credentials.

    • Aws::SharedCredentials - Used for loading static credentials from a shared file, such as ~/.aws/config.

    • Aws::AssumeRoleCredentials - Used when you need to assume a role.

    • Aws::AssumeRoleWebIdentityCredentials - Used when you need to assume a role after providing credentials via the web.

    • Aws::SSOCredentials - Used for loading credentials from AWS SSO using an access token generated from aws login.

    • Aws::ProcessCredentials - Used for loading credentials from a process that outputs to stdout.

    • Aws::InstanceProfileCredentials - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • Aws::ECSCredentials - Used for loading credentials from instances running in ECS.

    • Aws::CognitoIdentityCredentials - Used for loading credentials from the Cognito Identity service.

    When :credentials are not configured directly, the following locations will be searched for credentials:

    • Aws.config[:credentials]
    • The :access_key_id, :secret_access_key, :session_token, and :account_id options.
    • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'], ENV['AWS_SESSION_TOKEN'], and ENV['AWS_ACCOUNT_ID']
    • ~/.aws/credentials
    • ~/.aws/config
    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of Aws::InstanceProfileCredentials or Aws::ECSCredentials to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV['AWS_EC2_METADATA_DISABLED'] to true.
  • :region (required, String) —

    The AWS region to connect to. The configured :region is used to determine the service :endpoint. When not passed, a default :region is searched for in the following locations:

    • Aws.config[:region]
    • ENV['AWS_REGION']
    • ENV['AMAZON_REGION']
    • ENV['AWS_DEFAULT_REGION']
    • ~/.aws/credentials
    • ~/.aws/config
  • :access_key_id (String)
  • :account_id (String)
  • :active_endpoint_cache (Boolean) — default: false —

    When set to true, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to false.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true —

    Used only in adaptive retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a RetryCapacityNotAvailableError and will not retry instead of sleeping.

  • :client_side_monitoring (Boolean) — default: false —

    When true, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: "" —

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1" —

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000 —

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher —

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true —

    When true, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true —

    Used only in standard and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks.

  • :defaults_mode (String) — default: "legacy" —

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_host_prefix_injection (Boolean) — default: false —

    When true, the SDK will not prepend the modeled host prefix to the endpoint.

  • :disable_request_compression (Boolean) — default: false —

    When set to 'true' the request body will not be compressed for supported operations.

  • :endpoint (String, URI::HTTPS, URI::HTTP) —

    Normally you should not configure the :endpoint option directly. This is normally constructed from the :region option. Configuring :endpoint is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

    'http://example.com'
'https://example.com'
'http://example.com:123'
  • :endpoint_cache_max_entries (Integer) — default: 1000 —

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10 —

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60 —

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false —

    When set to true, endpoint discovery will be enabled for operations when available.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default —

    The log formatter.

  • :log_level (Symbol) — default: :info —

    The log level to send messages to the :logger at.

  • :logger (Logger) —

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3 —

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in standard and adaptive retry modes.

  • :profile (String) — default: "default" —

    Used when loading credentials from the shared credentials file at HOME/.aws/credentials. When not specified, 'default' is used.

  • :request_checksum_calculation (String) — default: "when_supported" —

    Determines when a checksum will be calculated for request payloads. Values are:

    • when_supported - (default) When set, a checksum will be calculated for all request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true and/or a requestAlgorithmMember is modeled.
    • when_required - When set, a checksum will only be calculated for request payloads of operations modeled with the httpChecksum trait where requestChecksumRequired is true or where a requestAlgorithmMember is modeled and supplied.
  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :response_checksum_validation (String) — default: "when_supported" —

    Determines when checksum validation will be performed on response payloads. Values are:

    • when_supported - (default) When set, checksum validation is performed on all response payloads of operations modeled with the httpChecksum trait where responseAlgorithms is modeled, except when no modeled checksum algorithms are supported.
    • when_required - When set, checksum validation is not performed on response payloads of operations unless the checksum algorithm is supported and the requestValidationModeMember member is set to ENABLED.
  • :retry_backoff (Proc) —

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the legacy retry mode.

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function. This option is only used in the legacy retry mode.

  • :retry_jitter (Symbol) — default: :none —

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the legacy retry mode.

    @see https://www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3 —

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the legacy retry mode.

  • :retry_max_delay (Integer) — default: 0 —

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the legacy retry mode.

  • :retry_mode (String) — default: "legacy" —

    Specifies which retry algorithm to use. Values are:

    • legacy - The pre-existing retry behavior. This is default value if no retry mode is provided.

    • standard - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • adaptive - An experimental retry mode that includes all the functionality of standard mode along with automatic client side throttling. This is a provisional mode that may change behavior in the future.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

  • :secret_access_key (String)
  • :session_token (String)
  • :sigv4a_signing_region_set (Array) —

    A list of regions that should be signed with SigV4a signing. When not passed, a default :sigv4a_signing_region_set is searched for in the following locations:

    • Aws.config[:sigv4a_signing_region_set]
    • ENV['AWS_SIGV4A_SIGNING_REGION_SET']
    • ~/.aws/config
  • :stub_responses (Boolean) — default: false —

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    Please note When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

    Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses NoOpTelemetryProvider which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the opentelemetry-sdk gem and then, pass in an instance of a Aws::Telemetry::OTelProvider for telemetry provider.
  • :token_provider (Aws::TokenProvider) —

    A Bearer Token Provider. This can be an instance of any one of the following classes:

    • Aws::StaticTokenProvider - Used for configuring static, non-refreshing tokens.

    • Aws::SSOTokenProvider - Used for loading tokens from AWS SSO using an access token generated from aws login.

    When :token_provider is not configured directly, the Aws::TokenProviderChain will be used to search for tokens configured for your profile in shared configuration files.

  • :use_dualstack_endpoint (Boolean) —

    When set to true, dualstack enabled endpoints (with .aws TLD) will be used if available.

  • :use_fips_endpoint (Boolean) —

    When set to true, fips compatible endpoints will be used if available. When a fips region is used, the region is normalized and this config is set to true.

  • :validate_params (Boolean) — default: true —

    When true, request parameters are validated before sending the request.

  • :endpoint_provider (Aws::Backup::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to #resolve_endpoint(parameters) where parameters is a Struct similar to Aws::Backup::EndpointParameters.

  • :http_continue_timeout (Float) — default: 1 —

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has "Expect" header set to "100-continue". Defaults to nil which disables this behaviour. This value can safely be set per request on the session.

  • :http_idle_timeout (Float) — default: 5 —

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_open_timeout (Float) — default: 15 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_proxy (URI::HTTP, String) —

    A proxy to send requests through. Formatted like 'http://proxy.com:123'.

  • :http_read_timeout (Float) — default: 60 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_wire_trace (Boolean) — default: false —

    When true, HTTP debug output will be sent to the :logger.

  • :on_chunk_received (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a content-length).

  • :on_chunk_sent (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

  • :raise_response_errors (Boolean) — default: true —

    When true, response errors are raised.

  • :ssl_ca_bundle (String) —

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass :ssl_ca_bundle or :ssl_ca_directory the the system default will be used if available.

  • :ssl_ca_directory (String) —

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass :ssl_ca_bundle or :ssl_ca_directory the the system default will be used if available.

  • :ssl_ca_store (String) —

    Sets the X509::Store to verify peer certificate.

  • :ssl_cert (OpenSSL::X509::Certificate) —

    Sets a client certificate when creating http connections.

  • :ssl_key (OpenSSL::PKey) —

    Sets a client key when creating http connections.

  • :ssl_timeout (Float) —

    Sets the SSL timeout in seconds

  • :ssl_verify_peer (Boolean) — default: true —

    When true, SSL peer certificates are verified when establishing a connection.



466
467
468
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 466

def initialize(*args)
  super
end

Instance Method Details

Removes the specified legal hold on a recovery point. This action can only be performed by a user with sufficient permissions.

Examples:

Request syntax with placeholder values


resp = client.cancel_legal_hold({
  legal_hold_id: "string", # required
  cancel_description: "string", # required
  retain_record_in_days: 1,
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :legal_hold_id (required, String) —

    The ID of the legal hold.

  • :cancel_description (required, String) —

    A string the describes the reason for removing the legal hold.

  • :retain_record_in_days (Integer) —

    The integer amount, in days, after which to remove legal hold.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



498
499
500
501
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 498

def cancel_legal_hold(params = {}, options = {})
  req = build_request(:cancel_legal_hold, params)
  req.send_request(options)
end

#create_backup_plan(params = {}) ⇒ Types::CreateBackupPlanOutput

Creates a backup plan using a backup plan name and backup rules. A backup plan is a document that contains information that Backup uses to schedule tasks that create recovery points for resources.

If you call CreateBackupPlan with a plan that already exists, you receive an AlreadyExistsException exception.

Examples:

Request syntax with placeholder values


resp = client.create_backup_plan({
  backup_plan: { # required
    backup_plan_name: "BackupPlanName", # required
    rules: [ # required
      {
        rule_name: "BackupRuleName", # required
        target_backup_vault_name: "BackupVaultName", # required
        schedule_expression: "CronExpression",
        start_window_minutes: 1,
        completion_window_minutes: 1,
        lifecycle: {
          move_to_cold_storage_after_days: 1,
          delete_after_days: 1,
          opt_in_to_archive_for_supported_resources: false,
        },
        recovery_point_tags: {
          "TagKey" => "TagValue",
        },
        copy_actions: [
          {
            lifecycle: {
              move_to_cold_storage_after_days: 1,
              delete_after_days: 1,
              opt_in_to_archive_for_supported_resources: false,
            },
            destination_backup_vault_arn: "ARN", # required
          },
        ],
        enable_continuous_backup: false,
        schedule_expression_timezone: "Timezone",
        index_actions: [
          {
            resource_types: ["ResourceType"],
          },
        ],
      },
    ],
    advanced_backup_settings: [
      {
        resource_type: "ResourceType",
        backup_options: {
          "BackupOptionKey" => "BackupOptionValue",
        },
      },
    ],
  },
  backup_plan_tags: {
    "TagKey" => "TagValue",
  },
  creator_request_id: "string",
})

Response structure


resp.backup_plan_id #=> String
resp.backup_plan_arn #=> String
resp.creation_date #=> Time
resp.version_id #=> String
resp.advanced_backup_settings #=> Array
resp.advanced_backup_settings[0].resource_type #=> String
resp.advanced_backup_settings[0].backup_options #=> Hash
resp.advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan (required, Types::BackupPlanInput) —

    The body of a backup plan. Includes a BackupPlanName and one or more sets of Rules.

  • :backup_plan_tags (Hash<String,String>) —

    The tags to assign to the backup plan.

  • :creator_request_id (String) —

    Identifies the request and allows failed requests to be retried without the risk of running the operation twice. If the request includes a CreatorRequestId that matches an existing backup plan, that plan is returned. This parameter is optional.

    If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.

Returns:

See Also:



603
604
605
606
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 603

def create_backup_plan(params = {}, options = {})
  req = build_request(:create_backup_plan, params)
  req.send_request(options)
end

#create_backup_selection(params = {}) ⇒ Types::CreateBackupSelectionOutput

Creates a JSON document that specifies a set of resources to assign to a backup plan. For examples, see Assigning resources programmatically.

Examples:

Request syntax with placeholder values


resp = client.create_backup_selection({
  backup_plan_id: "string", # required
  backup_selection: { # required
    selection_name: "BackupSelectionName", # required
    iam_role_arn: "IAMRoleArn", # required
    resources: ["ARN"],
    list_of_tags: [
      {
        condition_type: "STRINGEQUALS", # required, accepts STRINGEQUALS
        condition_key: "ConditionKey", # required
        condition_value: "ConditionValue", # required
      },
    ],
    not_resources: ["ARN"],
    conditions: {
      string_equals: [
        {
          condition_key: "ConditionKey",
          condition_value: "ConditionValue",
        },
      ],
      string_not_equals: [
        {
          condition_key: "ConditionKey",
          condition_value: "ConditionValue",
        },
      ],
      string_like: [
        {
          condition_key: "ConditionKey",
          condition_value: "ConditionValue",
        },
      ],
      string_not_like: [
        {
          condition_key: "ConditionKey",
          condition_value: "ConditionValue",
        },
      ],
    },
  },
  creator_request_id: "string",
})

Response structure


resp.selection_id #=> String
resp.backup_plan_id #=> String
resp.creation_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    The ID of the backup plan.

  • :backup_selection (required, Types::BackupSelection) —

    The body of a request to assign a set of resources to a backup plan.

  • :creator_request_id (String) —

    A unique string that identifies the request and allows failed requests to be retried without the risk of running the operation twice. This parameter is optional.

    If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.

Returns:

See Also:



692
693
694
695
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 692

def create_backup_selection(params = {}, options = {})
  req = build_request(:create_backup_selection, params)
  req.send_request(options)
end

#create_backup_vault(params = {}) ⇒ Types::CreateBackupVaultOutput

Creates a logical container where backups are stored. A CreateBackupVault request includes a name, optionally one or more resource tags, an encryption key, and a request ID.

Do not include sensitive data, such as passport numbers, in the name of a backup vault.

Examples:

Request syntax with placeholder values


resp = client.create_backup_vault({
  backup_vault_name: "BackupVaultName", # required
  backup_vault_tags: {
    "TagKey" => "TagValue",
  },
  encryption_key_arn: "ARN",
  creator_request_id: "string",
})

Response structure


resp.backup_vault_name #=> String
resp.backup_vault_arn #=> String
resp.creation_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created. They consist of letters, numbers, and hyphens.

  • :backup_vault_tags (Hash<String,String>) —

    The tags to assign to the backup vault.

  • :encryption_key_arn (String) —

    The server-side encryption key that is used to protect your backups; for example, arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab.

  • :creator_request_id (String) —

    A unique string that identifies the request and allows failed requests to be retried without the risk of running the operation twice. This parameter is optional.

    If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.

Returns:

See Also:



755
756
757
758
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 755

def create_backup_vault(params = {}, options = {})
  req = build_request(:create_backup_vault, params)
  req.send_request(options)
end

#create_framework(params = {}) ⇒ Types::CreateFrameworkOutput

Creates a framework with one or more controls. A framework is a collection of controls that you can use to evaluate your backup practices. By using pre-built customizable controls to define your policies, you can evaluate whether your backup practices comply with your policies and which resources are not yet in compliance.

Examples:

Request syntax with placeholder values


resp = client.create_framework({
  framework_name: "FrameworkName", # required
  framework_description: "FrameworkDescription",
  framework_controls: [ # required
    {
      control_name: "ControlName", # required
      control_input_parameters: [
        {
          parameter_name: "ParameterName",
          parameter_value: "ParameterValue",
        },
      ],
      control_scope: {
        compliance_resource_ids: ["string"],
        compliance_resource_types: ["ARN"],
        tags: {
          "string" => "string",
        },
      },
    },
  ],
  idempotency_token: "string",
  framework_tags: {
    "string" => "string",
  },
})

Response structure


resp.framework_name #=> String
resp.framework_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :framework_name (required, String) —

    The unique name of the framework. The name must be between 1 and 256 characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers (0-9), and underscores (_).

  • :framework_description (String) —

    An optional description of the framework with a maximum of 1,024 characters.

  • :framework_controls (required, Array<Types::FrameworkControl>) —

    The controls that make up the framework. Each control in the list has a name, input parameters, and scope.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to CreateFrameworkInput. Retrying a successful request with the same idempotency token results in a success message with no action taken.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

  • :framework_tags (Hash<String,String>) —

    The tags to assign to the framework.

Returns:

See Also:



834
835
836
837
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 834

def create_framework(params = {}, options = {})
  req = build_request(:create_framework, params)
  req.send_request(options)
end

#create_legal_hold(params = {}) ⇒ Types::CreateLegalHoldOutput

Creates a legal hold on a recovery point (backup). A legal hold is a restraint on altering or deleting a backup until an authorized user cancels the legal hold. Any actions to delete or disassociate a recovery point will fail with an error if one or more active legal holds are on the recovery point.

Examples:

Request syntax with placeholder values


resp = client.create_legal_hold({
  title: "string", # required
  description: "string", # required
  idempotency_token: "string",
  recovery_point_selection: {
    vault_names: ["string"],
    resource_identifiers: ["string"],
    date_range: {
      from_date: Time.now, # required
      to_date: Time.now, # required
    },
  },
  tags: {
    "TagKey" => "TagValue",
  },
})

Response structure


resp.title #=> String
resp.status #=> String, one of "CREATING", "ACTIVE", "CANCELING", "CANCELED"
resp.description #=> String
resp.legal_hold_id #=> String
resp.legal_hold_arn #=> String
resp.creation_date #=> Time
resp.recovery_point_selection.vault_names #=> Array
resp.recovery_point_selection.vault_names[0] #=> String
resp.recovery_point_selection.resource_identifiers #=> Array
resp.recovery_point_selection.resource_identifiers[0] #=> String
resp.recovery_point_selection.date_range.from_date #=> Time
resp.recovery_point_selection.date_range.to_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :title (required, String) —

    The title of the legal hold.

  • :description (required, String) —

    The description of the legal hold.

  • :idempotency_token (String) —

    This is a user-chosen string used to distinguish between otherwise identical calls. Retrying a successful request with the same idempotency token results in a success message with no action taken.

  • :recovery_point_selection (Types::RecoveryPointSelection) —

    The criteria to assign a set of resources, such as resource types or backup vaults.

  • :tags (Hash<String,String>) —

    Optional tags to include. A tag is a key-value pair you can use to manage, filter, and search for your resources. Allowed characters include UTF-8 letters, numbers, spaces, and the following characters: + - = . _ : /.

Returns:

See Also:



914
915
916
917
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 914

def create_legal_hold(params = {}, options = {})
  req = build_request(:create_legal_hold, params)
  req.send_request(options)
end

#create_logically_air_gapped_backup_vault(params = {}) ⇒ Types::CreateLogicallyAirGappedBackupVaultOutput

Creates a logical container to where backups may be copied.

This request includes a name, the Region, the maximum number of retention days, the minimum number of retention days, and optionally can include tags and a creator request ID.

Do not include sensitive data, such as passport numbers, in the name of a backup vault.

Examples:

Request syntax with placeholder values


resp = client.create_logically_air_gapped_backup_vault({
  backup_vault_name: "BackupVaultName", # required
  backup_vault_tags: {
    "TagKey" => "TagValue",
  },
  creator_request_id: "string",
  min_retention_days: 1, # required
  max_retention_days: 1, # required
})

Response structure


resp.backup_vault_name #=> String
resp.backup_vault_arn #=> String
resp.creation_date #=> Time
resp.vault_state #=> String, one of "CREATING", "AVAILABLE", "FAILED"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Logically air-gapped backup vaults are identified by names that are unique to the account used to create them and the Region where they are created.

  • :backup_vault_tags (Hash<String,String>) —

    The tags to assign to the vault.

  • :creator_request_id (String) —

    The ID of the creation request.

    This parameter is optional. If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.

  • :min_retention_days (required, Integer) —

    This setting specifies the minimum retention period that the vault retains its recovery points.

    The minimum value accepted is 7 days.

  • :max_retention_days (required, Integer) —

    The maximum retention period that the vault retains its recovery points.

Returns:

See Also:



984
985
986
987
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 984

def create_logically_air_gapped_backup_vault(params = {}, options = {})
  req = build_request(:create_logically_air_gapped_backup_vault, params)
  req.send_request(options)
end

#create_report_plan(params = {}) ⇒ Types::CreateReportPlanOutput

Creates a report plan. A report plan is a document that contains information about the contents of the report and where Backup will deliver it.

If you call CreateReportPlan with a plan that already exists, you receive an AlreadyExistsException exception.

Examples:

Request syntax with placeholder values


resp = client.create_report_plan({
  report_plan_name: "ReportPlanName", # required
  report_plan_description: "ReportPlanDescription",
  report_delivery_channel: { # required
    s3_bucket_name: "string", # required
    s3_key_prefix: "string",
    formats: ["string"],
  },
  report_setting: { # required
    report_template: "string", # required
    framework_arns: ["string"],
    number_of_frameworks: 1,
    accounts: ["string"],
    organization_units: ["string"],
    regions: ["string"],
  },
  report_plan_tags: {
    "string" => "string",
  },
  idempotency_token: "string",
})

Response structure


resp.report_plan_name #=> String
resp.report_plan_arn #=> String
resp.creation_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :report_plan_name (required, String) —

    The unique name of the report plan. The name must be between 1 and 256 characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers (0-9), and underscores (_).

  • :report_plan_description (String) —

    An optional description of the report plan with a maximum of 1,024 characters.

  • :report_delivery_channel (required, Types::ReportDeliveryChannel) —

    A structure that contains information about where and how to deliver your reports, specifically your Amazon S3 bucket name, S3 key prefix, and the formats of your reports.

  • :report_setting (required, Types::ReportSetting) —

    Identifies the report template for the report. Reports are built using a report template. The report templates are:

    RESOURCE_COMPLIANCE_REPORT | CONTROL_COMPLIANCE_REPORT | BACKUP_JOB_REPORT | COPY_JOB_REPORT | RESTORE_JOB_REPORT

    If the report template is RESOURCE_COMPLIANCE_REPORT or CONTROL_COMPLIANCE_REPORT, this API resource also describes the report coverage by Amazon Web Services Regions and frameworks.

  • :report_plan_tags (Hash<String,String>) —

    The tags to assign to the report plan.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to CreateReportPlanInput. Retrying a successful request with the same idempotency token results in a success message with no action taken.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



1073
1074
1075
1076
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1073

def create_report_plan(params = {}, options = {})
  req = build_request(:create_report_plan, params)
  req.send_request(options)
end

#create_restore_testing_plan(params = {}) ⇒ Types::CreateRestoreTestingPlanOutput

Creates a restore testing plan.

The first of two steps to create a restore testing plan. After this request is successful, finish the procedure using CreateRestoreTestingSelection.

Examples:

Request syntax with placeholder values


resp = client.create_restore_testing_plan({
  creator_request_id: "String",
  restore_testing_plan: { # required
    recovery_point_selection: { # required
      algorithm: "LATEST_WITHIN_WINDOW", # accepts LATEST_WITHIN_WINDOW, RANDOM_WITHIN_WINDOW
      exclude_vaults: ["string"],
      include_vaults: ["string"],
      recovery_point_types: ["CONTINUOUS"], # accepts CONTINUOUS, SNAPSHOT
      selection_window_days: 1,
    },
    restore_testing_plan_name: "String", # required
    schedule_expression: "String", # required
    schedule_expression_timezone: "String",
    start_window_hours: 1,
  },
  tags: {
    "String" => "String",
  },
})

Response structure


resp.creation_time #=> Time
resp.restore_testing_plan_arn #=> String
resp.restore_testing_plan_name #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creator_request_id (String) —

    This is a unique string that identifies the request and allows failed requests to be retriedwithout the risk of running the operation twice. This parameter is optional. If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.

  • :restore_testing_plan (required, Types::RestoreTestingPlanForCreate) —

    A restore testing plan must contain a unique RestoreTestingPlanName string you create and must contain a ScheduleExpression cron. You may optionally include a StartWindowHours integer and a CreatorRequestId string.

    The RestoreTestingPlanName is a unique string that is the name of the restore testing plan. This cannot be changed after creation, and it must consist of only alphanumeric characters and underscores.

  • :tags (Hash<String,String>) —

    The tags to assign to the restore testing plan.

Returns:

See Also:



1141
1142
1143
1144
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1141

def create_restore_testing_plan(params = {}, options = {})
  req = build_request(:create_restore_testing_plan, params)
  req.send_request(options)
end

#create_restore_testing_selection(params = {}) ⇒ Types::CreateRestoreTestingSelectionOutput

This request can be sent after CreateRestoreTestingPlan request returns successfully. This is the second part of creating a resource testing plan, and it must be completed sequentially.

This consists of RestoreTestingSelectionName, ProtectedResourceType, and one of the following:

  • ProtectedResourceArns

  • ProtectedResourceConditions

Each protected resource type can have one single value.

A restore testing selection can include a wildcard value ("*") for ProtectedResourceArns along with ProtectedResourceConditions. Alternatively, you can include up to 30 specific protected resource ARNs in ProtectedResourceArns.

Cannot select by both protected resource types AND specific ARNs. Request will fail if both are included.

Examples:

Request syntax with placeholder values


resp = client.create_restore_testing_selection({
  creator_request_id: "String",
  restore_testing_plan_name: "String", # required
  restore_testing_selection: { # required
    iam_role_arn: "String", # required
    protected_resource_arns: ["string"],
    protected_resource_conditions: {
      string_equals: [
        {
          key: "String", # required
          value: "String", # required
        },
      ],
      string_not_equals: [
        {
          key: "String", # required
          value: "String", # required
        },
      ],
    },
    protected_resource_type: "String", # required
    restore_metadata_overrides: {
      "String" => "String",
    },
    restore_testing_selection_name: "String", # required
    validation_window_hours: 1,
  },
})

Response structure


resp.creation_time #=> Time
resp.restore_testing_plan_arn #=> String
resp.restore_testing_plan_name #=> String
resp.restore_testing_selection_name #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creator_request_id (String) —

    This is an optional unique string that identifies the request and allows failed requests to be retried without the risk of running the operation twice. If used, this parameter must contain 1 to 50 alphanumeric or '-_.' characters.

  • :restore_testing_plan_name (required, String) —

    Input the restore testing plan name that was returned from the related CreateRestoreTestingPlan request.

  • :restore_testing_selection (required, Types::RestoreTestingSelectionForCreate) —

    This consists of RestoreTestingSelectionName, ProtectedResourceType, and one of the following:

    • ProtectedResourceArns

    • ProtectedResourceConditions

    Each protected resource type can have one single value.

    A restore testing selection can include a wildcard value ("*") for ProtectedResourceArns along with ProtectedResourceConditions. Alternatively, you can include up to 30 specific protected resource ARNs in ProtectedResourceArns.

Returns:

See Also:



1241
1242
1243
1244
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1241

def create_restore_testing_selection(params = {}, options = {})
  req = build_request(:create_restore_testing_selection, params)
  req.send_request(options)
end

#delete_backup_plan(params = {}) ⇒ Types::DeleteBackupPlanOutput

Deletes a backup plan. A backup plan can only be deleted after all associated selections of resources have been deleted. Deleting a backup plan deletes the current version of a backup plan. Previous versions, if any, will still exist.

Examples:

Request syntax with placeholder values


resp = client.delete_backup_plan({
  backup_plan_id: "string", # required
})

Response structure


resp.backup_plan_id #=> String
resp.backup_plan_arn #=> String
resp.deletion_date #=> Time
resp.version_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    Uniquely identifies a backup plan.

Returns:

See Also:



1278
1279
1280
1281
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1278

def delete_backup_plan(params = {}, options = {})
  req = build_request(:delete_backup_plan, params)
  req.send_request(options)
end

#delete_backup_selection(params = {}) ⇒ Struct

Deletes the resource selection associated with a backup plan that is specified by the SelectionId.

Examples:

Request syntax with placeholder values


resp = client.delete_backup_selection({
  backup_plan_id: "string", # required
  selection_id: "string", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    Uniquely identifies a backup plan.

  • :selection_id (required, String) —

    Uniquely identifies the body of a request to assign a set of resources to a backup plan.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1306
1307
1308
1309
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1306

def delete_backup_selection(params = {}, options = {})
  req = build_request(:delete_backup_selection, params)
  req.send_request(options)
end

#delete_backup_vault(params = {}) ⇒ Struct

Deletes the backup vault identified by its name. A vault can be deleted only if it is empty.

Examples:

Request syntax with placeholder values


resp = client.delete_backup_vault({
  backup_vault_name: "string", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1331
1332
1333
1334
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1331

def delete_backup_vault(params = {}, options = {})
  req = build_request(:delete_backup_vault, params)
  req.send_request(options)
end

#delete_backup_vault_access_policy(params = {}) ⇒ Struct

Deletes the policy document that manages permissions on a backup vault.

Examples:

Request syntax with placeholder values


resp = client.delete_backup_vault_access_policy({
  backup_vault_name: "BackupVaultName", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created. They consist of lowercase letters, numbers, and hyphens.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1357
1358
1359
1360
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1357

def delete_backup_vault_access_policy(params = {}, options = {})
  req = build_request(:delete_backup_vault_access_policy, params)
  req.send_request(options)
end

#delete_backup_vault_lock_configuration(params = {}) ⇒ Struct

Deletes Backup Vault Lock from a backup vault specified by a backup vault name.

If the Vault Lock configuration is immutable, then you cannot delete Vault Lock using API operations, and you will receive an InvalidRequestException if you attempt to do so. For more information, see Vault Lock in the Backup Developer Guide.

Examples:

Request syntax with placeholder values


resp = client.delete_backup_vault_lock_configuration({
  backup_vault_name: "BackupVaultName", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of the backup vault from which to delete Backup Vault Lock.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1389
1390
1391
1392
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1389

def delete_backup_vault_lock_configuration(params = {}, options = {})
  req = build_request(:delete_backup_vault_lock_configuration, params)
  req.send_request(options)
end

#delete_backup_vault_notifications(params = {}) ⇒ Struct

Deletes event notifications for the specified backup vault.

Examples:

Request syntax with placeholder values


resp = client.delete_backup_vault_notifications({
  backup_vault_name: "BackupVaultName", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Region where they are created.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1413
1414
1415
1416
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1413

def delete_backup_vault_notifications(params = {}, options = {})
  req = build_request(:delete_backup_vault_notifications, params)
  req.send_request(options)
end

#delete_framework(params = {}) ⇒ Struct

Deletes the framework specified by a framework name.

Examples:

Request syntax with placeholder values


resp = client.delete_framework({
  framework_name: "FrameworkName", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :framework_name (required, String) —

    The unique name of a framework.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1435
1436
1437
1438
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1435

def delete_framework(params = {}, options = {})
  req = build_request(:delete_framework, params)
  req.send_request(options)
end

#delete_recovery_point(params = {}) ⇒ Struct

Deletes the recovery point specified by a recovery point ID.

If the recovery point ID belongs to a continuous backup, calling this endpoint deletes the existing continuous backup and stops future continuous backup.

When an IAM role's permissions are insufficient to call this API, the service sends back an HTTP 200 response with an empty HTTP body, but the recovery point is not deleted. Instead, it enters an EXPIRED state.

EXPIRED recovery points can be deleted with this API once the IAM role has the iam:CreateServiceLinkedRole action. To learn more about adding this role, see Troubleshooting manual deletions.

If the user or role is deleted or the permission within the role is removed, the deletion will not be successful and will enter an EXPIRED state.

Examples:

Request syntax with placeholder values


resp = client.delete_recovery_point({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :recovery_point_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1486
1487
1488
1489
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1486

def delete_recovery_point(params = {}, options = {})
  req = build_request(:delete_recovery_point, params)
  req.send_request(options)
end

#delete_report_plan(params = {}) ⇒ Struct

Deletes the report plan specified by a report plan name.

Examples:

Request syntax with placeholder values


resp = client.delete_report_plan({
  report_plan_name: "ReportPlanName", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :report_plan_name (required, String) —

    The unique name of a report plan.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1508
1509
1510
1511
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1508

def delete_report_plan(params = {}, options = {})
  req = build_request(:delete_report_plan, params)
  req.send_request(options)
end

#delete_restore_testing_plan(params = {}) ⇒ Struct

This request deletes the specified restore testing plan.

Deletion can only successfully occur if all associated restore testing selections are deleted first.

Examples:

Request syntax with placeholder values


resp = client.delete_restore_testing_plan({
  restore_testing_plan_name: "String", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_testing_plan_name (required, String) —

    Required unique name of the restore testing plan you wish to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1533
1534
1535
1536
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1533

def delete_restore_testing_plan(params = {}, options = {})
  req = build_request(:delete_restore_testing_plan, params)
  req.send_request(options)
end

#delete_restore_testing_selection(params = {}) ⇒ Struct

Input the Restore Testing Plan name and Restore Testing Selection name.

All testing selections associated with a restore testing plan must be deleted before the restore testing plan can be deleted.

Examples:

Request syntax with placeholder values


resp = client.delete_restore_testing_selection({
  restore_testing_plan_name: "String", # required
  restore_testing_selection_name: "String", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_testing_plan_name (required, String) —

    Required unique name of the restore testing plan that contains the restore testing selection you wish to delete.

  • :restore_testing_selection_name (required, String) —

    Required unique name of the restore testing selection you wish to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1565
1566
1567
1568
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1565

def delete_restore_testing_selection(params = {}, options = {})
  req = build_request(:delete_restore_testing_selection, params)
  req.send_request(options)
end

#describe_backup_job(params = {}) ⇒ Types::DescribeBackupJobOutput

Returns backup job details for the specified BackupJobId.

Examples:

Request syntax with placeholder values


resp = client.describe_backup_job({
  backup_job_id: "string", # required
})

Response structure


resp. #=> String
resp.backup_job_id #=> String
resp.backup_vault_name #=> String
resp.backup_vault_arn #=> String
resp.recovery_point_arn #=> String
resp.resource_arn #=> String
resp.creation_date #=> Time
resp.completion_date #=> Time
resp.state #=> String, one of "CREATED", "PENDING", "RUNNING", "ABORTING", "ABORTED", "COMPLETED", "FAILED", "EXPIRED", "PARTIAL"
resp.status_message #=> String
resp.percent_done #=> String
resp.backup_size_in_bytes #=> Integer
resp.iam_role_arn #=> String
resp.created_by.backup_plan_id #=> String
resp.created_by.backup_plan_arn #=> String
resp.created_by.backup_plan_version #=> String
resp.created_by.backup_rule_id #=> String
resp.resource_type #=> String
resp.bytes_transferred #=> Integer
resp.expected_completion_date #=> Time
resp.start_by #=> Time
resp.backup_options #=> Hash
resp.backup_options["BackupOptionKey"] #=> String
resp.backup_type #=> String
resp.parent_job_id #=> String
resp.is_parent #=> Boolean
resp.number_of_child_jobs #=> Integer
resp.child_jobs_in_state #=> Hash
resp.child_jobs_in_state["BackupJobState"] #=> Integer
resp.resource_name #=> String
resp.initiation_date #=> Time
resp.message_category #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_job_id (required, String) —

    Uniquely identifies a request to Backup to back up a resource.

Returns:

See Also:



1650
1651
1652
1653
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1650

def describe_backup_job(params = {}, options = {})
  req = build_request(:describe_backup_job, params)
  req.send_request(options)
end

#describe_backup_vault(params = {}) ⇒ Types::DescribeBackupVaultOutput

Returns metadata about a backup vault specified by its name.

Examples:

Request syntax with placeholder values


resp = client.describe_backup_vault({
  backup_vault_name: "string", # required
  backup_vault_account_id: "string",
})

Response structure


resp.backup_vault_name #=> String
resp.backup_vault_arn #=> String
resp.vault_type #=> String, one of "BACKUP_VAULT", "LOGICALLY_AIR_GAPPED_BACKUP_VAULT"
resp.vault_state #=> String, one of "CREATING", "AVAILABLE", "FAILED"
resp.encryption_key_arn #=> String
resp.creation_date #=> Time
resp.creator_request_id #=> String
resp.number_of_recovery_points #=> Integer
resp.locked #=> Boolean
resp.min_retention_days #=> Integer
resp.max_retention_days #=> Integer
resp.lock_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :backup_vault_account_id (String) —

    The account ID of the specified backup vault.

Returns:

See Also:



1706
1707
1708
1709
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1706

def describe_backup_vault(params = {}, options = {})
  req = build_request(:describe_backup_vault, params)
  req.send_request(options)
end

#describe_copy_job(params = {}) ⇒ Types::DescribeCopyJobOutput

Returns metadata associated with creating a copy of a resource.

Examples:

Request syntax with placeholder values


resp = client.describe_copy_job({
  copy_job_id: "string", # required
})

Response structure


resp.copy_job. #=> String
resp.copy_job.copy_job_id #=> String
resp.copy_job.source_backup_vault_arn #=> String
resp.copy_job.source_recovery_point_arn #=> String
resp.copy_job.destination_backup_vault_arn #=> String
resp.copy_job.destination_recovery_point_arn #=> String
resp.copy_job.resource_arn #=> String
resp.copy_job.creation_date #=> Time
resp.copy_job.completion_date #=> Time
resp.copy_job.state #=> String, one of "CREATED", "RUNNING", "COMPLETED", "FAILED", "PARTIAL"
resp.copy_job.status_message #=> String
resp.copy_job.backup_size_in_bytes #=> Integer
resp.copy_job.iam_role_arn #=> String
resp.copy_job.created_by.backup_plan_id #=> String
resp.copy_job.created_by.backup_plan_arn #=> String
resp.copy_job.created_by.backup_plan_version #=> String
resp.copy_job.created_by.backup_rule_id #=> String
resp.copy_job.resource_type #=> String
resp.copy_job.parent_job_id #=> String
resp.copy_job.is_parent #=> Boolean
resp.copy_job.composite_member_identifier #=> String
resp.copy_job.number_of_child_jobs #=> Integer
resp.copy_job.child_jobs_in_state #=> Hash
resp.copy_job.child_jobs_in_state["CopyJobState"] #=> Integer
resp.copy_job.resource_name #=> String
resp.copy_job.message_category #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :copy_job_id (required, String) —

    Uniquely identifies a copy job.

Returns:

See Also:



1759
1760
1761
1762
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1759

def describe_copy_job(params = {}, options = {})
  req = build_request(:describe_copy_job, params)
  req.send_request(options)
end

#describe_framework(params = {}) ⇒ Types::DescribeFrameworkOutput

Returns the framework details for the specified FrameworkName.

Examples:

Request syntax with placeholder values


resp = client.describe_framework({
  framework_name: "FrameworkName", # required
})

Response structure


resp.framework_name #=> String
resp.framework_arn #=> String
resp.framework_description #=> String
resp.framework_controls #=> Array
resp.framework_controls[0].control_name #=> String
resp.framework_controls[0].control_input_parameters #=> Array
resp.framework_controls[0].control_input_parameters[0].parameter_name #=> String
resp.framework_controls[0].control_input_parameters[0].parameter_value #=> String
resp.framework_controls[0].control_scope.compliance_resource_ids #=> Array
resp.framework_controls[0].control_scope.compliance_resource_ids[0] #=> String
resp.framework_controls[0].control_scope.compliance_resource_types #=> Array
resp.framework_controls[0].control_scope.compliance_resource_types[0] #=> String
resp.framework_controls[0].control_scope.tags #=> Hash
resp.framework_controls[0].control_scope.tags["string"] #=> String
resp.creation_time #=> Time
resp.deployment_status #=> String
resp.framework_status #=> String
resp.idempotency_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :framework_name (required, String) —

    The unique name of a framework.

Returns:

See Also:



1811
1812
1813
1814
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1811

def describe_framework(params = {}, options = {})
  req = build_request(:describe_framework, params)
  req.send_request(options)
end

#describe_global_settings(params = {}) ⇒ Types::DescribeGlobalSettingsOutput

Describes whether the Amazon Web Services account is opted in to cross-account backup. Returns an error if the account is not a member of an Organizations organization. Example: describe-global-settings --region us-west-2

Examples:

Response structure


resp.global_settings #=> Hash
resp.global_settings["GlobalSettingsName"] #=> String
resp.last_update_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



1836
1837
1838
1839
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1836

def describe_global_settings(params = {}, options = {})
  req = build_request(:describe_global_settings, params)
  req.send_request(options)
end

#describe_protected_resource(params = {}) ⇒ Types::DescribeProtectedResourceOutput

Returns information about a saved resource, including the last time it was backed up, its Amazon Resource Name (ARN), and the Amazon Web Services service type of the saved resource.

Examples:

Request syntax with placeholder values


resp = client.describe_protected_resource({
  resource_arn: "ARN", # required
})

Response structure


resp.resource_arn #=> String
resp.resource_type #=> String
resp.last_backup_time #=> Time
resp.resource_name #=> String
resp.last_backup_vault_arn #=> String
resp.last_recovery_point_arn #=> String
resp.latest_restore_execution_time_minutes #=> Integer
resp.latest_restore_job_creation_date #=> Time
resp.latest_restore_recovery_point_creation_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a resource. The format of the ARN depends on the resource type.

Returns:

See Also:



1883
1884
1885
1886
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1883

def describe_protected_resource(params = {}, options = {})
  req = build_request(:describe_protected_resource, params)
  req.send_request(options)
end

#describe_recovery_point(params = {}) ⇒ Types::DescribeRecoveryPointOutput

Returns metadata associated with a recovery point, including ID, status, encryption, and lifecycle.

Examples:

Request syntax with placeholder values


resp = client.describe_recovery_point({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
  backup_vault_account_id: "AccountId",
})

Response structure


resp.recovery_point_arn #=> String
resp.backup_vault_name #=> String
resp.backup_vault_arn #=> String
resp.source_backup_vault_arn #=> String
resp.resource_arn #=> String
resp.resource_type #=> String
resp.created_by.backup_plan_id #=> String
resp.created_by.backup_plan_arn #=> String
resp.created_by.backup_plan_version #=> String
resp.created_by.backup_rule_id #=> String
resp.iam_role_arn #=> String
resp.status #=> String, one of "COMPLETED", "PARTIAL", "DELETING", "EXPIRED"
resp.status_message #=> String
resp.creation_date #=> Time
resp.completion_date #=> Time
resp.backup_size_in_bytes #=> Integer
resp.calculated_lifecycle.move_to_cold_storage_at #=> Time
resp.calculated_lifecycle.delete_at #=> Time
resp.lifecycle.move_to_cold_storage_after_days #=> Integer
resp.lifecycle.delete_after_days #=> Integer
resp.lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.encryption_key_arn #=> String
resp.is_encrypted #=> Boolean
resp.storage_class #=> String, one of "WARM", "COLD", "DELETED"
resp.last_restore_time #=> Time
resp.parent_recovery_point_arn #=> String
resp.composite_member_identifier #=> String
resp.is_parent #=> Boolean
resp.resource_name #=> String
resp.vault_type #=> String, one of "BACKUP_VAULT", "LOGICALLY_AIR_GAPPED_BACKUP_VAULT"
resp.index_status #=> String, one of "PENDING", "ACTIVE", "FAILED", "DELETING"
resp.index_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :recovery_point_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

  • :backup_vault_account_id (String) —

    The account ID of the specified backup vault.

Returns:

See Also:



1980
1981
1982
1983
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 1980

def describe_recovery_point(params = {}, options = {})
  req = build_request(:describe_recovery_point, params)
  req.send_request(options)
end

#describe_region_settings(params = {}) ⇒ Types::DescribeRegionSettingsOutput

Returns the current service opt-in settings for the Region. If service opt-in is enabled for a service, Backup tries to protect that service's resources in this Region, when the resource is included in an on-demand backup or scheduled backup plan. Otherwise, Backup does not try to protect that service's resources in this Region.

Examples:

Response structure


resp.resource_type_opt_in_preference #=> Hash
resp.resource_type_opt_in_preference["ResourceType"] #=> Boolean
resp.resource_type_management_preference #=> Hash
resp.resource_type_management_preference["ResourceType"] #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



2007
2008
2009
2010
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2007

def describe_region_settings(params = {}, options = {})
  req = build_request(:describe_region_settings, params)
  req.send_request(options)
end

#describe_report_job(params = {}) ⇒ Types::DescribeReportJobOutput

Returns the details associated with creating a report as specified by its ReportJobId.

Examples:

Request syntax with placeholder values


resp = client.describe_report_job({
  report_job_id: "ReportJobId", # required
})

Response structure


resp.report_job.report_job_id #=> String
resp.report_job.report_plan_arn #=> String
resp.report_job.report_template #=> String
resp.report_job.creation_time #=> Time
resp.report_job.completion_time #=> Time
resp.report_job.status #=> String
resp.report_job.status_message #=> String
resp.report_job.report_destination.s3_bucket_name #=> String
resp.report_job.report_destination.s3_keys #=> Array
resp.report_job.report_destination.s3_keys[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :report_job_id (required, String) —

    The identifier of the report job. A unique, randomly generated, Unicode, UTF-8 encoded string that is at most 1,024 bytes long. The report job ID cannot be edited.

Returns:

See Also:



2047
2048
2049
2050
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2047

def describe_report_job(params = {}, options = {})
  req = build_request(:describe_report_job, params)
  req.send_request(options)
end

#describe_report_plan(params = {}) ⇒ Types::DescribeReportPlanOutput

Returns a list of all report plans for an Amazon Web Services account and Amazon Web Services Region.

Examples:

Request syntax with placeholder values


resp = client.describe_report_plan({
  report_plan_name: "ReportPlanName", # required
})

Response structure


resp.report_plan.report_plan_arn #=> String
resp.report_plan.report_plan_name #=> String
resp.report_plan.report_plan_description #=> String
resp.report_plan.report_setting.report_template #=> String
resp.report_plan.report_setting.framework_arns #=> Array
resp.report_plan.report_setting.framework_arns[0] #=> String
resp.report_plan.report_setting.number_of_frameworks #=> Integer
resp.report_plan.report_setting.accounts #=> Array
resp.report_plan.report_setting.accounts[0] #=> String
resp.report_plan.report_setting.organization_units #=> Array
resp.report_plan.report_setting.organization_units[0] #=> String
resp.report_plan.report_setting.regions #=> Array
resp.report_plan.report_setting.regions[0] #=> String
resp.report_plan.report_delivery_channel.s3_bucket_name #=> String
resp.report_plan.report_delivery_channel.s3_key_prefix #=> String
resp.report_plan.report_delivery_channel.formats #=> Array
resp.report_plan.report_delivery_channel.formats[0] #=> String
resp.report_plan.deployment_status #=> String
resp.report_plan.creation_time #=> Time
resp.report_plan.last_attempted_execution_time #=> Time
resp.report_plan.last_successful_execution_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :report_plan_name (required, String) —

    The unique name of a report plan.

Returns:

See Also:



2096
2097
2098
2099
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2096

def describe_report_plan(params = {}, options = {})
  req = build_request(:describe_report_plan, params)
  req.send_request(options)
end

#describe_restore_job(params = {}) ⇒ Types::DescribeRestoreJobOutput

Returns metadata associated with a restore job that is specified by a job ID.

Examples:

Request syntax with placeholder values


resp = client.describe_restore_job({
  restore_job_id: "RestoreJobId", # required
})

Response structure


resp. #=> String
resp.restore_job_id #=> String
resp.recovery_point_arn #=> String
resp.creation_date #=> Time
resp.completion_date #=> Time
resp.status #=> String, one of "PENDING", "RUNNING", "COMPLETED", "ABORTED", "FAILED"
resp.status_message #=> String
resp.percent_done #=> String
resp.backup_size_in_bytes #=> Integer
resp.iam_role_arn #=> String
resp.expected_completion_time_minutes #=> Integer
resp.created_resource_arn #=> String
resp.resource_type #=> String
resp.recovery_point_creation_date #=> Time
resp.created_by.restore_testing_plan_arn #=> String
resp.validation_status #=> String, one of "FAILED", "SUCCESSFUL", "TIMED_OUT", "VALIDATING"
resp.validation_status_message #=> String
resp.deletion_status #=> String, one of "DELETING", "FAILED", "SUCCESSFUL"
resp.deletion_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_job_id (required, String) —

    Uniquely identifies the job that restores a recovery point.

Returns:

See Also:



2161
2162
2163
2164
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2161

def describe_restore_job(params = {}, options = {})
  req = build_request(:describe_restore_job, params)
  req.send_request(options)
end

#disassociate_recovery_point(params = {}) ⇒ Struct

Deletes the specified continuous backup recovery point from Backup and releases control of that continuous backup to the source service, such as Amazon RDS. The source service will continue to create and retain continuous backups using the lifecycle that you specified in your original backup plan.

Does not support snapshot backup recovery points.

Examples:

Request syntax with placeholder values


resp = client.disassociate_recovery_point({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The unique name of an Backup vault.

  • :recovery_point_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies an Backup recovery point.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2194
2195
2196
2197
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2194

def disassociate_recovery_point(params = {}, options = {})
  req = build_request(:disassociate_recovery_point, params)
  req.send_request(options)
end

#disassociate_recovery_point_from_parent(params = {}) ⇒ Struct

This action to a specific child (nested) recovery point removes the relationship between the specified recovery point and its parent (composite) recovery point.

Examples:

Request syntax with placeholder values


resp = client.disassociate_recovery_point_from_parent({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where the child (nested) recovery point is stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :recovery_point_arn (required, String) —

    The Amazon Resource Name (ARN) that uniquely identifies the child (nested) recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2227
2228
2229
2230
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2227

def disassociate_recovery_point_from_parent(params = {}, options = {})
  req = build_request(:disassociate_recovery_point_from_parent, params)
  req.send_request(options)
end

#export_backup_plan_template(params = {}) ⇒ Types::ExportBackupPlanTemplateOutput

Returns the backup plan that is specified by the plan ID as a backup template.

Examples:

Request syntax with placeholder values


resp = client.export_backup_plan_template({
  backup_plan_id: "string", # required
})

Response structure


resp.backup_plan_template_json #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    Uniquely identifies a backup plan.

Returns:

See Also:



2256
2257
2258
2259
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2256

def export_backup_plan_template(params = {}, options = {})
  req = build_request(:export_backup_plan_template, params)
  req.send_request(options)
end

#get_backup_plan(params = {}) ⇒ Types::GetBackupPlanOutput

Returns BackupPlan details for the specified BackupPlanId. The details are the body of a backup plan in JSON format, in addition to plan metadata.

Examples:

Request syntax with placeholder values


resp = client.get_backup_plan({
  backup_plan_id: "string", # required
  version_id: "string",
})

Response structure


resp.backup_plan.backup_plan_name #=> String
resp.backup_plan.rules #=> Array
resp.backup_plan.rules[0].rule_name #=> String
resp.backup_plan.rules[0].target_backup_vault_name #=> String
resp.backup_plan.rules[0].schedule_expression #=> String
resp.backup_plan.rules[0].start_window_minutes #=> Integer
resp.backup_plan.rules[0].completion_window_minutes #=> Integer
resp.backup_plan.rules[0].lifecycle.move_to_cold_storage_after_days #=> Integer
resp.backup_plan.rules[0].lifecycle.delete_after_days #=> Integer
resp.backup_plan.rules[0].lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.backup_plan.rules[0].recovery_point_tags #=> Hash
resp.backup_plan.rules[0].recovery_point_tags["TagKey"] #=> String
resp.backup_plan.rules[0].rule_id #=> String
resp.backup_plan.rules[0].copy_actions #=> Array
resp.backup_plan.rules[0].copy_actions[0].lifecycle.move_to_cold_storage_after_days #=> Integer
resp.backup_plan.rules[0].copy_actions[0].lifecycle.delete_after_days #=> Integer
resp.backup_plan.rules[0].copy_actions[0].lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.backup_plan.rules[0].copy_actions[0].destination_backup_vault_arn #=> String
resp.backup_plan.rules[0].enable_continuous_backup #=> Boolean
resp.backup_plan.rules[0].schedule_expression_timezone #=> String
resp.backup_plan.rules[0].index_actions #=> Array
resp.backup_plan.rules[0].index_actions[0].resource_types #=> Array
resp.backup_plan.rules[0].index_actions[0].resource_types[0] #=> String
resp.backup_plan.advanced_backup_settings #=> Array
resp.backup_plan.advanced_backup_settings[0].resource_type #=> String
resp.backup_plan.advanced_backup_settings[0].backup_options #=> Hash
resp.backup_plan.advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String
resp.backup_plan_id #=> String
resp.backup_plan_arn #=> String
resp.version_id #=> String
resp.creator_request_id #=> String
resp.creation_date #=> Time
resp.deletion_date #=> Time
resp.last_execution_date #=> Time
resp.advanced_backup_settings #=> Array
resp.advanced_backup_settings[0].resource_type #=> String
resp.advanced_backup_settings[0].backup_options #=> Hash
resp.advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    Uniquely identifies a backup plan.

  • :version_id (String) —

    Unique, randomly generated, Unicode, UTF-8 encoded strings that are at most 1,024 bytes long. Version IDs cannot be edited.

Returns:

See Also:



2336
2337
2338
2339
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2336

def get_backup_plan(params = {}, options = {})
  req = build_request(:get_backup_plan, params)
  req.send_request(options)
end

#get_backup_plan_from_json(params = {}) ⇒ Types::GetBackupPlanFromJSONOutput

Returns a valid JSON document specifying a backup plan or an error.

Examples:

Request syntax with placeholder values


resp = client.get_backup_plan_from_json({
  backup_plan_template_json: "string", # required
})

Response structure


resp.backup_plan.backup_plan_name #=> String
resp.backup_plan.rules #=> Array
resp.backup_plan.rules[0].rule_name #=> String
resp.backup_plan.rules[0].target_backup_vault_name #=> String
resp.backup_plan.rules[0].schedule_expression #=> String
resp.backup_plan.rules[0].start_window_minutes #=> Integer
resp.backup_plan.rules[0].completion_window_minutes #=> Integer
resp.backup_plan.rules[0].lifecycle.move_to_cold_storage_after_days #=> Integer
resp.backup_plan.rules[0].lifecycle.delete_after_days #=> Integer
resp.backup_plan.rules[0].lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.backup_plan.rules[0].recovery_point_tags #=> Hash
resp.backup_plan.rules[0].recovery_point_tags["TagKey"] #=> String
resp.backup_plan.rules[0].rule_id #=> String
resp.backup_plan.rules[0].copy_actions #=> Array
resp.backup_plan.rules[0].copy_actions[0].lifecycle.move_to_cold_storage_after_days #=> Integer
resp.backup_plan.rules[0].copy_actions[0].lifecycle.delete_after_days #=> Integer
resp.backup_plan.rules[0].copy_actions[0].lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.backup_plan.rules[0].copy_actions[0].destination_backup_vault_arn #=> String
resp.backup_plan.rules[0].enable_continuous_backup #=> Boolean
resp.backup_plan.rules[0].schedule_expression_timezone #=> String
resp.backup_plan.rules[0].index_actions #=> Array
resp.backup_plan.rules[0].index_actions[0].resource_types #=> Array
resp.backup_plan.rules[0].index_actions[0].resource_types[0] #=> String
resp.backup_plan.advanced_backup_settings #=> Array
resp.backup_plan.advanced_backup_settings[0].resource_type #=> String
resp.backup_plan.advanced_backup_settings[0].backup_options #=> Hash
resp.backup_plan.advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_template_json (required, String) —

    A customer-supplied backup plan document in JSON format.

Returns:

See Also:



2390
2391
2392
2393
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2390

def get_backup_plan_from_json(params = {}, options = {})
  req = build_request(:get_backup_plan_from_json, params)
  req.send_request(options)
end

#get_backup_plan_from_template(params = {}) ⇒ Types::GetBackupPlanFromTemplateOutput

Returns the template specified by its templateId as a backup plan.

Examples:

Request syntax with placeholder values


resp = client.get_backup_plan_from_template({
  backup_plan_template_id: "string", # required
})

Response structure


resp.backup_plan_document.backup_plan_name #=> String
resp.backup_plan_document.rules #=> Array
resp.backup_plan_document.rules[0].rule_name #=> String
resp.backup_plan_document.rules[0].target_backup_vault_name #=> String
resp.backup_plan_document.rules[0].schedule_expression #=> String
resp.backup_plan_document.rules[0].start_window_minutes #=> Integer
resp.backup_plan_document.rules[0].completion_window_minutes #=> Integer
resp.backup_plan_document.rules[0].lifecycle.move_to_cold_storage_after_days #=> Integer
resp.backup_plan_document.rules[0].lifecycle.delete_after_days #=> Integer
resp.backup_plan_document.rules[0].lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.backup_plan_document.rules[0].recovery_point_tags #=> Hash
resp.backup_plan_document.rules[0].recovery_point_tags["TagKey"] #=> String
resp.backup_plan_document.rules[0].rule_id #=> String
resp.backup_plan_document.rules[0].copy_actions #=> Array
resp.backup_plan_document.rules[0].copy_actions[0].lifecycle.move_to_cold_storage_after_days #=> Integer
resp.backup_plan_document.rules[0].copy_actions[0].lifecycle.delete_after_days #=> Integer
resp.backup_plan_document.rules[0].copy_actions[0].lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.backup_plan_document.rules[0].copy_actions[0].destination_backup_vault_arn #=> String
resp.backup_plan_document.rules[0].enable_continuous_backup #=> Boolean
resp.backup_plan_document.rules[0].schedule_expression_timezone #=> String
resp.backup_plan_document.rules[0].index_actions #=> Array
resp.backup_plan_document.rules[0].index_actions[0].resource_types #=> Array
resp.backup_plan_document.rules[0].index_actions[0].resource_types[0] #=> String
resp.backup_plan_document.advanced_backup_settings #=> Array
resp.backup_plan_document.advanced_backup_settings[0].resource_type #=> String
resp.backup_plan_document.advanced_backup_settings[0].backup_options #=> Hash
resp.backup_plan_document.advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_template_id (required, String) —

    Uniquely identifies a stored backup plan template.

Returns:

See Also:



2444
2445
2446
2447
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2444

def get_backup_plan_from_template(params = {}, options = {})
  req = build_request(:get_backup_plan_from_template, params)
  req.send_request(options)
end

#get_backup_selection(params = {}) ⇒ Types::GetBackupSelectionOutput

Returns selection metadata and a document in JSON format that specifies a list of resources that are associated with a backup plan.

Examples:

Request syntax with placeholder values


resp = client.get_backup_selection({
  backup_plan_id: "string", # required
  selection_id: "string", # required
})

Response structure


resp.backup_selection.selection_name #=> String
resp.backup_selection.iam_role_arn #=> String
resp.backup_selection.resources #=> Array
resp.backup_selection.resources[0] #=> String
resp.backup_selection.list_of_tags #=> Array
resp.backup_selection.list_of_tags[0].condition_type #=> String, one of "STRINGEQUALS"
resp.backup_selection.list_of_tags[0].condition_key #=> String
resp.backup_selection.list_of_tags[0].condition_value #=> String
resp.backup_selection.not_resources #=> Array
resp.backup_selection.not_resources[0] #=> String
resp.backup_selection.conditions.string_equals #=> Array
resp.backup_selection.conditions.string_equals[0].condition_key #=> String
resp.backup_selection.conditions.string_equals[0].condition_value #=> String
resp.backup_selection.conditions.string_not_equals #=> Array
resp.backup_selection.conditions.string_not_equals[0].condition_key #=> String
resp.backup_selection.conditions.string_not_equals[0].condition_value #=> String
resp.backup_selection.conditions.string_like #=> Array
resp.backup_selection.conditions.string_like[0].condition_key #=> String
resp.backup_selection.conditions.string_like[0].condition_value #=> String
resp.backup_selection.conditions.string_not_like #=> Array
resp.backup_selection.conditions.string_not_like[0].condition_key #=> String
resp.backup_selection.conditions.string_not_like[0].condition_value #=> String
resp.selection_id #=> String
resp.backup_plan_id #=> String
resp.creation_date #=> Time
resp.creator_request_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    Uniquely identifies a backup plan.

  • :selection_id (required, String) —

    Uniquely identifies the body of a request to assign a set of resources to a backup plan.

Returns:

See Also:



2507
2508
2509
2510
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2507

def get_backup_selection(params = {}, options = {})
  req = build_request(:get_backup_selection, params)
  req.send_request(options)
end

#get_backup_vault_access_policy(params = {}) ⇒ Types::GetBackupVaultAccessPolicyOutput

Returns the access policy document that is associated with the named backup vault.

Examples:

Request syntax with placeholder values


resp = client.get_backup_vault_access_policy({
  backup_vault_name: "BackupVaultName", # required
})

Response structure


resp.backup_vault_name #=> String
resp.backup_vault_arn #=> String
resp.policy #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

Returns:

See Also:



2542
2543
2544
2545
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2542

def get_backup_vault_access_policy(params = {}, options = {})
  req = build_request(:get_backup_vault_access_policy, params)
  req.send_request(options)
end

#get_backup_vault_notifications(params = {}) ⇒ Types::GetBackupVaultNotificationsOutput

Returns event notifications for the specified backup vault.

Examples:

Request syntax with placeholder values


resp = client.get_backup_vault_notifications({
  backup_vault_name: "BackupVaultName", # required
})

Response structure


resp.backup_vault_name #=> String
resp.backup_vault_arn #=> String
resp.sns_topic_arn #=> String
resp.backup_vault_events #=> Array
resp.backup_vault_events[0] #=> String, one of "BACKUP_JOB_STARTED", "BACKUP_JOB_COMPLETED", "BACKUP_JOB_SUCCESSFUL", "BACKUP_JOB_FAILED", "BACKUP_JOB_EXPIRED", "RESTORE_JOB_STARTED", "RESTORE_JOB_COMPLETED", "RESTORE_JOB_SUCCESSFUL", "RESTORE_JOB_FAILED", "COPY_JOB_STARTED", "COPY_JOB_SUCCESSFUL", "COPY_JOB_FAILED", "RECOVERY_POINT_MODIFIED", "BACKUP_PLAN_CREATED", "BACKUP_PLAN_MODIFIED", "S3_BACKUP_OBJECT_FAILED", "S3_RESTORE_OBJECT_FAILED"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

Returns:

See Also:



2579
2580
2581
2582
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2579

def get_backup_vault_notifications(params = {}, options = {})
  req = build_request(:get_backup_vault_notifications, params)
  req.send_request(options)
end

#get_legal_hold(params = {}) ⇒ Types::GetLegalHoldOutput

This action returns details for a specified legal hold. The details are the body of a legal hold in JSON format, in addition to metadata.

Examples:

Request syntax with placeholder values


resp = client.get_legal_hold({
  legal_hold_id: "string", # required
})

Response structure


resp.title #=> String
resp.status #=> String, one of "CREATING", "ACTIVE", "CANCELING", "CANCELED"
resp.description #=> String
resp.cancel_description #=> String
resp.legal_hold_id #=> String
resp.legal_hold_arn #=> String
resp.creation_date #=> Time
resp.cancellation_date #=> Time
resp.retain_record_until #=> Time
resp.recovery_point_selection.vault_names #=> Array
resp.recovery_point_selection.vault_names[0] #=> String
resp.recovery_point_selection.resource_identifiers #=> Array
resp.recovery_point_selection.resource_identifiers[0] #=> String
resp.recovery_point_selection.date_range.from_date #=> Time
resp.recovery_point_selection.date_range.to_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :legal_hold_id (required, String) —

    The ID of the legal hold.

Returns:

See Also:



2631
2632
2633
2634
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2631

def get_legal_hold(params = {}, options = {})
  req = build_request(:get_legal_hold, params)
  req.send_request(options)
end

#get_recovery_point_index_details(params = {}) ⇒ Types::GetRecoveryPointIndexDetailsOutput

This operation returns the metadata and details specific to the backup index associated with the specified recovery point.

Examples:

Request syntax with placeholder values


resp = client.get_recovery_point_index_details({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
})

Response structure


resp.recovery_point_arn #=> String
resp.backup_vault_arn #=> String
resp.source_resource_arn #=> String
resp.index_creation_date #=> Time
resp.index_deletion_date #=> Time
resp.index_completion_date #=> Time
resp.index_status #=> String, one of "PENDING", "ACTIVE", "FAILED", "DELETING"
resp.index_status_message #=> String
resp.total_items_indexed #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Region where they are created.

    Accepted characters include lowercase letters, numbers, and hyphens.

  • :recovery_point_arn (required, String) —

    An ARN that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

Returns:

See Also:



2685
2686
2687
2688
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2685

def get_recovery_point_index_details(params = {}, options = {})
  req = build_request(:get_recovery_point_index_details, params)
  req.send_request(options)
end

#get_recovery_point_restore_metadata(params = {}) ⇒ Types::GetRecoveryPointRestoreMetadataOutput

Returns a set of metadata key-value pairs that were used to create the backup.

Examples:

Request syntax with placeholder values


resp = client.get_recovery_point_restore_metadata({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
  backup_vault_account_id: "AccountId",
})

Response structure


resp.backup_vault_arn #=> String
resp.recovery_point_arn #=> String
resp.restore_metadata #=> Hash
resp.restore_metadata["MetadataKey"] #=> String
resp.resource_type #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :recovery_point_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

  • :backup_vault_account_id (String) —

    The account ID of the specified backup vault.

Returns:

See Also:



2733
2734
2735
2736
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2733

def get_recovery_point_restore_metadata(params = {}, options = {})
  req = build_request(:get_recovery_point_restore_metadata, params)
  req.send_request(options)
end

#get_restore_job_metadata(params = {}) ⇒ Types::GetRestoreJobMetadataOutput

This request returns the metadata for the specified restore job.

Examples:

Request syntax with placeholder values


resp = client.get_restore_job_metadata({
  restore_job_id: "RestoreJobId", # required
})

Response structure


resp.restore_job_id #=> String
resp.metadata #=> Hash
resp.metadata["MetadataKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_job_id (required, String) —

    This is a unique identifier of a restore job within Backup.

Returns:

See Also:



2764
2765
2766
2767
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2764

def get_restore_job_metadata(params = {}, options = {})
  req = build_request(:get_restore_job_metadata, params)
  req.send_request(options)
end

#get_restore_testing_inferred_metadata(params = {}) ⇒ Types::GetRestoreTestingInferredMetadataOutput

This request returns the minimal required set of metadata needed to start a restore job with secure default settings. BackupVaultName and RecoveryPointArn are required parameters. BackupVaultAccountId is an optional parameter.

Examples:

Request syntax with placeholder values


resp = client.get_restore_testing_inferred_metadata({
  backup_vault_account_id: "String",
  backup_vault_name: "String", # required
  recovery_point_arn: "String", # required
})

Response structure


resp.inferred_metadata #=> Hash
resp.inferred_metadata["string"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_account_id (String) —

    The account ID of the specified backup vault.

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web ServicesRegion where they are created. They consist of letters, numbers, and hyphens.

  • :recovery_point_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

Returns:

See Also:



2809
2810
2811
2812
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2809

def get_restore_testing_inferred_metadata(params = {}, options = {})
  req = build_request(:get_restore_testing_inferred_metadata, params)
  req.send_request(options)
end

#get_restore_testing_plan(params = {}) ⇒ Types::GetRestoreTestingPlanOutput

Returns RestoreTestingPlan details for the specified RestoreTestingPlanName. The details are the body of a restore testing plan in JSON format, in addition to plan metadata.

Examples:

Request syntax with placeholder values


resp = client.get_restore_testing_plan({
  restore_testing_plan_name: "String", # required
})

Response structure


resp.restore_testing_plan.creation_time #=> Time
resp.restore_testing_plan.creator_request_id #=> String
resp.restore_testing_plan.last_execution_time #=> Time
resp.restore_testing_plan.last_update_time #=> Time
resp.restore_testing_plan.recovery_point_selection.algorithm #=> String, one of "LATEST_WITHIN_WINDOW", "RANDOM_WITHIN_WINDOW"
resp.restore_testing_plan.recovery_point_selection.exclude_vaults #=> Array
resp.restore_testing_plan.recovery_point_selection.exclude_vaults[0] #=> String
resp.restore_testing_plan.recovery_point_selection.include_vaults #=> Array
resp.restore_testing_plan.recovery_point_selection.include_vaults[0] #=> String
resp.restore_testing_plan.recovery_point_selection.recovery_point_types #=> Array
resp.restore_testing_plan.recovery_point_selection.recovery_point_types[0] #=> String, one of "CONTINUOUS", "SNAPSHOT"
resp.restore_testing_plan.recovery_point_selection.selection_window_days #=> Integer
resp.restore_testing_plan.restore_testing_plan_arn #=> String
resp.restore_testing_plan.restore_testing_plan_name #=> String
resp.restore_testing_plan.schedule_expression #=> String
resp.restore_testing_plan.schedule_expression_timezone #=> String
resp.restore_testing_plan.start_window_hours #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_testing_plan_name (required, String) —

    Required unique name of the restore testing plan.

Returns:

See Also:



2855
2856
2857
2858
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2855

def get_restore_testing_plan(params = {}, options = {})
  req = build_request(:get_restore_testing_plan, params)
  req.send_request(options)
end

#get_restore_testing_selection(params = {}) ⇒ Types::GetRestoreTestingSelectionOutput

Returns RestoreTestingSelection, which displays resources and elements of the restore testing plan.

Examples:

Request syntax with placeholder values


resp = client.get_restore_testing_selection({
  restore_testing_plan_name: "String", # required
  restore_testing_selection_name: "String", # required
})

Response structure


resp.restore_testing_selection.creation_time #=> Time
resp.restore_testing_selection.creator_request_id #=> String
resp.restore_testing_selection.iam_role_arn #=> String
resp.restore_testing_selection.protected_resource_arns #=> Array
resp.restore_testing_selection.protected_resource_arns[0] #=> String
resp.restore_testing_selection.protected_resource_conditions.string_equals #=> Array
resp.restore_testing_selection.protected_resource_conditions.string_equals[0].key #=> String
resp.restore_testing_selection.protected_resource_conditions.string_equals[0].value #=> String
resp.restore_testing_selection.protected_resource_conditions.string_not_equals #=> Array
resp.restore_testing_selection.protected_resource_conditions.string_not_equals[0].key #=> String
resp.restore_testing_selection.protected_resource_conditions.string_not_equals[0].value #=> String
resp.restore_testing_selection.protected_resource_type #=> String
resp.restore_testing_selection.restore_metadata_overrides #=> Hash
resp.restore_testing_selection.restore_metadata_overrides["String"] #=> String
resp.restore_testing_selection.restore_testing_plan_name #=> String
resp.restore_testing_selection.restore_testing_selection_name #=> String
resp.restore_testing_selection.validation_window_hours #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_testing_plan_name (required, String) —

    Required unique name of the restore testing plan.

  • :restore_testing_selection_name (required, String) —

    Required unique name of the restore testing selection.

Returns:

See Also:



2904
2905
2906
2907
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2904

def get_restore_testing_selection(params = {}, options = {})
  req = build_request(:get_restore_testing_selection, params)
  req.send_request(options)
end

#get_supported_resource_types(params = {}) ⇒ Types::GetSupportedResourceTypesOutput

Returns the Amazon Web Services resource types supported by Backup.

Examples:

Response structure


resp.resource_types #=> Array
resp.resource_types[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



2924
2925
2926
2927
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 2924

def get_supported_resource_types(params = {}, options = {})
  req = build_request(:get_supported_resource_types, params)
  req.send_request(options)
end

#list_backup_job_summaries(params = {}) ⇒ Types::ListBackupJobSummariesOutput

This is a request for a summary of backup jobs created or running within the most recent 30 days. You can include parameters AccountID, State, ResourceType, MessageCategory, AggregationPeriod, MaxResults, or NextToken to filter results.

This request returns a summary that contains Region, Account, State, ResourceType, MessageCategory, StartTime, EndTime, and Count of included jobs.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_backup_job_summaries({
  account_id: "AccountId",
  state: "CREATED", # accepts CREATED, PENDING, RUNNING, ABORTING, ABORTED, COMPLETED, FAILED, EXPIRED, PARTIAL, AGGREGATE_ALL, ANY
  resource_type: "ResourceType",
  message_category: "MessageCategory",
  aggregation_period: "ONE_DAY", # accepts ONE_DAY, SEVEN_DAYS, FOURTEEN_DAYS
  max_results: 1,
  next_token: "string",
})

Response structure


resp.backup_job_summaries #=> Array
resp.backup_job_summaries[0].region #=> String
resp.backup_job_summaries[0]. #=> String
resp.backup_job_summaries[0].state #=> String, one of "CREATED", "PENDING", "RUNNING", "ABORTING", "ABORTED", "COMPLETED", "FAILED", "EXPIRED", "PARTIAL", "AGGREGATE_ALL", "ANY"
resp.backup_job_summaries[0].resource_type #=> String
resp.backup_job_summaries[0].message_category #=> String
resp.backup_job_summaries[0].count #=> Integer
resp.backup_job_summaries[0].start_time #=> Time
resp.backup_job_summaries[0].end_time #=> Time
resp.aggregation_period #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :account_id (String) —

    Returns the job count for the specified account.

    If the request is sent from a member account or an account not part of Amazon Web Services Organizations, jobs within requestor's account will be returned.

    Root, admin, and delegated administrator accounts can use the value ANY to return job counts from every account in the organization.

    AGGREGATE_ALL aggregates job counts from all accounts within the authenticated organization, then returns the sum.

  • :state (String) —

    This parameter returns the job count for jobs with the specified state.

    The the value ANY returns count of all states.

    AGGREGATE_ALL aggregates job counts for all states and returns the sum.

    Completed with issues is a status found only in the Backup console. For API, this status refers to jobs with a state of COMPLETED and a MessageCategory with a value other than SUCCESS; that is, the status is completed but comes with a status message. To obtain the job count for Completed with issues, run two GET requests, and subtract the second, smaller number:

    GET /audit/backup-job-summaries?AggregationPeriod=FOURTEEN_DAYS&State=COMPLETED

    GET /audit/backup-job-summaries?AggregationPeriod=FOURTEEN_DAYS&MessageCategory=SUCCESS&State=COMPLETED

  • :resource_type (String) —

    Returns the job count for the specified resource type. Use request GetSupportedResourceTypes to obtain strings for supported resource types.

    The the value ANY returns count of all resource types.

    AGGREGATE_ALL aggregates job counts for all resource types and returns the sum.

    The type of Amazon Web Services resource to be backed up; for example, an Amazon Elastic Block Store (Amazon EBS) volume or an Amazon Relational Database Service (Amazon RDS) database.

  • :message_category (String) —

    This parameter returns the job count for the specified message category.

    Example accepted strings include AccessDenied, Success, and InvalidParameters. See Monitoring for a list of accepted MessageCategory strings.

    The the value ANY returns count of all message categories.

    AGGREGATE_ALL aggregates job counts for all message categories and returns the sum.

  • :aggregation_period (String) —

    The period for the returned results.

    • ONE_DAY - The daily job count for the prior 14 days.

    • SEVEN_DAYS - The aggregated job count for the prior 7 days.

    • FOURTEEN_DAYS - The aggregated job count for prior 14 days.

  • :max_results (Integer) —

    The maximum number of items to be returned.

    The value is an integer. Range of accepted values is from 1 to 500.

  • :next_token (String) —

    The next item following a partial list of returned resources. For example, if a request is made to return MaxResults number of resources, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

Returns:

See Also:



3062
3063
3064
3065
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3062

def list_backup_job_summaries(params = {}, options = {})
  req = build_request(:list_backup_job_summaries, params)
  req.send_request(options)
end

#list_backup_jobs(params = {}) ⇒ Types::ListBackupJobsOutput

Returns a list of existing backup jobs for an authenticated account for the last 30 days. For a longer period of time, consider using these monitoring tools.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_backup_jobs({
  next_token: "string",
  max_results: 1,
  by_resource_arn: "ARN",
  by_state: "CREATED", # accepts CREATED, PENDING, RUNNING, ABORTING, ABORTED, COMPLETED, FAILED, EXPIRED, PARTIAL
  by_backup_vault_name: "BackupVaultName",
  by_created_before: Time.now,
  by_created_after: Time.now,
  by_resource_type: "ResourceType",
  by_account_id: "AccountId",
  by_complete_after: Time.now,
  by_complete_before: Time.now,
  by_parent_job_id: "string",
  by_message_category: "string",
})

Response structure


resp.backup_jobs #=> Array
resp.backup_jobs[0]. #=> String
resp.backup_jobs[0].backup_job_id #=> String
resp.backup_jobs[0].backup_vault_name #=> String
resp.backup_jobs[0].backup_vault_arn #=> String
resp.backup_jobs[0].recovery_point_arn #=> String
resp.backup_jobs[0].resource_arn #=> String
resp.backup_jobs[0].creation_date #=> Time
resp.backup_jobs[0].completion_date #=> Time
resp.backup_jobs[0].state #=> String, one of "CREATED", "PENDING", "RUNNING", "ABORTING", "ABORTED", "COMPLETED", "FAILED", "EXPIRED", "PARTIAL"
resp.backup_jobs[0].status_message #=> String
resp.backup_jobs[0].percent_done #=> String
resp.backup_jobs[0].backup_size_in_bytes #=> Integer
resp.backup_jobs[0].iam_role_arn #=> String
resp.backup_jobs[0].created_by.backup_plan_id #=> String
resp.backup_jobs[0].created_by.backup_plan_arn #=> String
resp.backup_jobs[0].created_by.backup_plan_version #=> String
resp.backup_jobs[0].created_by.backup_rule_id #=> String
resp.backup_jobs[0].expected_completion_date #=> Time
resp.backup_jobs[0].start_by #=> Time
resp.backup_jobs[0].resource_type #=> String
resp.backup_jobs[0].bytes_transferred #=> Integer
resp.backup_jobs[0].backup_options #=> Hash
resp.backup_jobs[0].backup_options["BackupOptionKey"] #=> String
resp.backup_jobs[0].backup_type #=> String
resp.backup_jobs[0].parent_job_id #=> String
resp.backup_jobs[0].is_parent #=> Boolean
resp.backup_jobs[0].resource_name #=> String
resp.backup_jobs[0].initiation_date #=> Time
resp.backup_jobs[0].message_category #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

  • :by_resource_arn (String) —

    Returns only backup jobs that match the specified resource Amazon Resource Name (ARN).

  • :by_state (String) —

    Returns only backup jobs that are in the specified state.

    Completed with issues is a status found only in the Backup console. For API, this status refers to jobs with a state of COMPLETED and a MessageCategory with a value other than SUCCESS; that is, the status is completed but comes with a status message.

    To obtain the job count for Completed with issues, run two GET requests, and subtract the second, smaller number:

    GET /backup-jobs/?state=COMPLETED

    GET /backup-jobs/?messageCategory=SUCCESS&state=COMPLETED

  • :by_backup_vault_name (String) —

    Returns only backup jobs that will be stored in the specified backup vault. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :by_created_before (Time, DateTime, Date, Integer, String) —

    Returns only backup jobs that were created before the specified date.

  • :by_created_after (Time, DateTime, Date, Integer, String) —

    Returns only backup jobs that were created after the specified date.

  • :by_resource_type (String) —

    Returns only backup jobs for the specified resources:

    • Aurora for Amazon Aurora

    • CloudFormation for CloudFormation

    • DocumentDB for Amazon DocumentDB (with MongoDB compatibility)

    • DynamoDB for Amazon DynamoDB

    • EBS for Amazon Elastic Block Store

    • EC2 for Amazon Elastic Compute Cloud

    • EFS for Amazon Elastic File System

    • FSx for Amazon FSx

    • Neptune for Amazon Neptune

    • RDS for Amazon Relational Database Service

    • Redshift for Amazon Redshift

    • S3 for Amazon Simple Storage Service (Amazon S3)

    • SAP HANA on Amazon EC2 for SAP HANA databases on Amazon Elastic Compute Cloud instances

    • Storage Gateway for Storage Gateway

    • Timestream for Amazon Timestream

    • VirtualMachine for VMware virtual machines

  • :by_account_id (String) —

    The account ID to list the jobs from. Returns only backup jobs associated with the specified account ID.

    If used from an Organizations management account, passing * returns all jobs across the organization.

  • :by_complete_after (Time, DateTime, Date, Integer, String) —

    Returns only backup jobs completed after a date expressed in Unix format and Coordinated Universal Time (UTC).

  • :by_complete_before (Time, DateTime, Date, Integer, String) —

    Returns only backup jobs completed before a date expressed in Unix format and Coordinated Universal Time (UTC).

  • :by_parent_job_id (String) —

    This is a filter to list child (nested) jobs based on parent job ID.

  • :by_message_category (String) —

    This is an optional parameter that can be used to filter out jobs with a MessageCategory which matches the value you input.

    Example strings may include AccessDenied, SUCCESS, AGGREGATE_ALL, and InvalidParameters.

    View Monitoring

    The wildcard () returns count of all message categories.

    AGGREGATE_ALL aggregates job counts for all message categories and returns the sum.

Returns:

See Also:



3250
3251
3252
3253
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3250

def list_backup_jobs(params = {}, options = {})
  req = build_request(:list_backup_jobs, params)
  req.send_request(options)
end

#list_backup_plan_templates(params = {}) ⇒ Types::ListBackupPlanTemplatesOutput

Lists the backup plan templates.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_backup_plan_templates({
  next_token: "string",
  max_results: 1,
})

Response structure


resp.next_token #=> String
resp.backup_plan_templates_list #=> Array
resp.backup_plan_templates_list[0].backup_plan_template_id #=> String
resp.backup_plan_templates_list[0].backup_plan_template_name #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to return.

Returns:

See Also:



3291
3292
3293
3294
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3291

def list_backup_plan_templates(params = {}, options = {})
  req = build_request(:list_backup_plan_templates, params)
  req.send_request(options)
end

#list_backup_plan_versions(params = {}) ⇒ Types::ListBackupPlanVersionsOutput

Returns version metadata of your backup plans, including Amazon Resource Names (ARNs), backup plan IDs, creation and deletion dates, plan names, and version IDs.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_backup_plan_versions({
  backup_plan_id: "string", # required
  next_token: "string",
  max_results: 1,
})

Response structure


resp.next_token #=> String
resp.backup_plan_versions_list #=> Array
resp.backup_plan_versions_list[0].backup_plan_arn #=> String
resp.backup_plan_versions_list[0].backup_plan_id #=> String
resp.backup_plan_versions_list[0].creation_date #=> Time
resp.backup_plan_versions_list[0].deletion_date #=> Time
resp.backup_plan_versions_list[0].version_id #=> String
resp.backup_plan_versions_list[0].backup_plan_name #=> String
resp.backup_plan_versions_list[0].creator_request_id #=> String
resp.backup_plan_versions_list[0].last_execution_date #=> Time
resp.backup_plan_versions_list[0].advanced_backup_settings #=> Array
resp.backup_plan_versions_list[0].advanced_backup_settings[0].resource_type #=> String
resp.backup_plan_versions_list[0].advanced_backup_settings[0].backup_options #=> Hash
resp.backup_plan_versions_list[0].advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    Uniquely identifies a backup plan.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

Returns:

See Also:



3348
3349
3350
3351
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3348

def list_backup_plan_versions(params = {}, options = {})
  req = build_request(:list_backup_plan_versions, params)
  req.send_request(options)
end

#list_backup_plans(params = {}) ⇒ Types::ListBackupPlansOutput

Lists the active backup plans for the account.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_backup_plans({
  next_token: "string",
  max_results: 1,
  include_deleted: false,
})

Response structure


resp.next_token #=> String
resp.backup_plans_list #=> Array
resp.backup_plans_list[0].backup_plan_arn #=> String
resp.backup_plans_list[0].backup_plan_id #=> String
resp.backup_plans_list[0].creation_date #=> Time
resp.backup_plans_list[0].deletion_date #=> Time
resp.backup_plans_list[0].version_id #=> String
resp.backup_plans_list[0].backup_plan_name #=> String
resp.backup_plans_list[0].creator_request_id #=> String
resp.backup_plans_list[0].last_execution_date #=> Time
resp.backup_plans_list[0].advanced_backup_settings #=> Array
resp.backup_plans_list[0].advanced_backup_settings[0].resource_type #=> String
resp.backup_plans_list[0].advanced_backup_settings[0].backup_options #=> Hash
resp.backup_plans_list[0].advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

  • :include_deleted (Boolean) —

    A Boolean value with a default value of FALSE that returns deleted backup plans when set to TRUE.

Returns:

See Also:



3404
3405
3406
3407
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3404

def list_backup_plans(params = {}, options = {})
  req = build_request(:list_backup_plans, params)
  req.send_request(options)
end

#list_backup_selections(params = {}) ⇒ Types::ListBackupSelectionsOutput

Returns an array containing metadata of the resources associated with the target backup plan.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_backup_selections({
  backup_plan_id: "string", # required
  next_token: "string",
  max_results: 1,
})

Response structure


resp.next_token #=> String
resp.backup_selections_list #=> Array
resp.backup_selections_list[0].selection_id #=> String
resp.backup_selections_list[0].selection_name #=> String
resp.backup_selections_list[0].backup_plan_id #=> String
resp.backup_selections_list[0].creation_date #=> Time
resp.backup_selections_list[0].creator_request_id #=> String
resp.backup_selections_list[0].iam_role_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    Uniquely identifies a backup plan.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

Returns:

See Also:



3454
3455
3456
3457
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3454

def list_backup_selections(params = {}, options = {})
  req = build_request(:list_backup_selections, params)
  req.send_request(options)
end

#list_backup_vaults(params = {}) ⇒ Types::ListBackupVaultsOutput

Returns a list of recovery point storage containers along with information about them.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_backup_vaults({
  by_vault_type: "BACKUP_VAULT", # accepts BACKUP_VAULT, LOGICALLY_AIR_GAPPED_BACKUP_VAULT
  by_shared: false,
  next_token: "string",
  max_results: 1,
})

Response structure


resp.backup_vault_list #=> Array
resp.backup_vault_list[0].backup_vault_name #=> String
resp.backup_vault_list[0].backup_vault_arn #=> String
resp.backup_vault_list[0].vault_type #=> String, one of "BACKUP_VAULT", "LOGICALLY_AIR_GAPPED_BACKUP_VAULT"
resp.backup_vault_list[0].vault_state #=> String, one of "CREATING", "AVAILABLE", "FAILED"
resp.backup_vault_list[0].creation_date #=> Time
resp.backup_vault_list[0].encryption_key_arn #=> String
resp.backup_vault_list[0].creator_request_id #=> String
resp.backup_vault_list[0].number_of_recovery_points #=> Integer
resp.backup_vault_list[0].locked #=> Boolean
resp.backup_vault_list[0].min_retention_days #=> Integer
resp.backup_vault_list[0].max_retention_days #=> Integer
resp.backup_vault_list[0].lock_date #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :by_vault_type (String) —

    This parameter will sort the list of vaults by vault type.

  • :by_shared (Boolean) —

    This parameter will sort the list of vaults by shared vaults.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

Returns:

See Also:



3514
3515
3516
3517
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3514

def list_backup_vaults(params = {}, options = {})
  req = build_request(:list_backup_vaults, params)
  req.send_request(options)
end

#list_copy_job_summaries(params = {}) ⇒ Types::ListCopyJobSummariesOutput

This request obtains a list of copy jobs created or running within the the most recent 30 days. You can include parameters AccountID, State, ResourceType, MessageCategory, AggregationPeriod, MaxResults, or NextToken to filter results.

This request returns a summary that contains Region, Account, State, RestourceType, MessageCategory, StartTime, EndTime, and Count of included jobs.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_copy_job_summaries({
  account_id: "AccountId",
  state: "CREATED", # accepts CREATED, RUNNING, ABORTING, ABORTED, COMPLETING, COMPLETED, FAILING, FAILED, PARTIAL, AGGREGATE_ALL, ANY
  resource_type: "ResourceType",
  message_category: "MessageCategory",
  aggregation_period: "ONE_DAY", # accepts ONE_DAY, SEVEN_DAYS, FOURTEEN_DAYS
  max_results: 1,
  next_token: "string",
})

Response structure


resp.copy_job_summaries #=> Array
resp.copy_job_summaries[0].region #=> String
resp.copy_job_summaries[0]. #=> String
resp.copy_job_summaries[0].state #=> String, one of "CREATED", "RUNNING", "ABORTING", "ABORTED", "COMPLETING", "COMPLETED", "FAILING", "FAILED", "PARTIAL", "AGGREGATE_ALL", "ANY"
resp.copy_job_summaries[0].resource_type #=> String
resp.copy_job_summaries[0].message_category #=> String
resp.copy_job_summaries[0].count #=> Integer
resp.copy_job_summaries[0].start_time #=> Time
resp.copy_job_summaries[0].end_time #=> Time
resp.aggregation_period #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :account_id (String) —

    Returns the job count for the specified account.

    If the request is sent from a member account or an account not part of Amazon Web Services Organizations, jobs within requestor's account will be returned.

    Root, admin, and delegated administrator accounts can use the value ANY to return job counts from every account in the organization.

    AGGREGATE_ALL aggregates job counts from all accounts within the authenticated organization, then returns the sum.

  • :state (String) —

    This parameter returns the job count for jobs with the specified state.

    The the value ANY returns count of all states.

    AGGREGATE_ALL aggregates job counts for all states and returns the sum.

  • :resource_type (String) —

    Returns the job count for the specified resource type. Use request GetSupportedResourceTypes to obtain strings for supported resource types.

    The the value ANY returns count of all resource types.

    AGGREGATE_ALL aggregates job counts for all resource types and returns the sum.

    The type of Amazon Web Services resource to be backed up; for example, an Amazon Elastic Block Store (Amazon EBS) volume or an Amazon Relational Database Service (Amazon RDS) database.

  • :message_category (String) —

    This parameter returns the job count for the specified message category.

    Example accepted strings include AccessDenied, Success, and InvalidParameters. See Monitoring for a list of accepted MessageCategory strings.

    The the value ANY returns count of all message categories.

    AGGREGATE_ALL aggregates job counts for all message categories and returns the sum.

  • :aggregation_period (String) —

    The period for the returned results.

    • ONE_DAY - The daily job count for the prior 14 days.

    • SEVEN_DAYS - The aggregated job count for the prior 7 days.

    • FOURTEEN_DAYS - The aggregated job count for prior 14 days.

  • :max_results (Integer) —

    This parameter sets the maximum number of items to be returned.

    The value is an integer. Range of accepted values is from 1 to 500.

  • :next_token (String) —

    The next item following a partial list of returned resources. For example, if a request is made to return MaxResults number of resources, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

Returns:

See Also:



3639
3640
3641
3642
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3639

def list_copy_job_summaries(params = {}, options = {})
  req = build_request(:list_copy_job_summaries, params)
  req.send_request(options)
end

#list_copy_jobs(params = {}) ⇒ Types::ListCopyJobsOutput

Returns metadata about your copy jobs.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_copy_jobs({
  next_token: "string",
  max_results: 1,
  by_resource_arn: "ARN",
  by_state: "CREATED", # accepts CREATED, RUNNING, COMPLETED, FAILED, PARTIAL
  by_created_before: Time.now,
  by_created_after: Time.now,
  by_resource_type: "ResourceType",
  by_destination_vault_arn: "string",
  by_account_id: "AccountId",
  by_complete_before: Time.now,
  by_complete_after: Time.now,
  by_parent_job_id: "string",
  by_message_category: "string",
})

Response structure


resp.copy_jobs #=> Array
resp.copy_jobs[0]. #=> String
resp.copy_jobs[0].copy_job_id #=> String
resp.copy_jobs[0].source_backup_vault_arn #=> String
resp.copy_jobs[0].source_recovery_point_arn #=> String
resp.copy_jobs[0].destination_backup_vault_arn #=> String
resp.copy_jobs[0].destination_recovery_point_arn #=> String
resp.copy_jobs[0].resource_arn #=> String
resp.copy_jobs[0].creation_date #=> Time
resp.copy_jobs[0].completion_date #=> Time
resp.copy_jobs[0].state #=> String, one of "CREATED", "RUNNING", "COMPLETED", "FAILED", "PARTIAL"
resp.copy_jobs[0].status_message #=> String
resp.copy_jobs[0].backup_size_in_bytes #=> Integer
resp.copy_jobs[0].iam_role_arn #=> String
resp.copy_jobs[0].created_by.backup_plan_id #=> String
resp.copy_jobs[0].created_by.backup_plan_arn #=> String
resp.copy_jobs[0].created_by.backup_plan_version #=> String
resp.copy_jobs[0].created_by.backup_rule_id #=> String
resp.copy_jobs[0].resource_type #=> String
resp.copy_jobs[0].parent_job_id #=> String
resp.copy_jobs[0].is_parent #=> Boolean
resp.copy_jobs[0].composite_member_identifier #=> String
resp.copy_jobs[0].number_of_child_jobs #=> Integer
resp.copy_jobs[0].child_jobs_in_state #=> Hash
resp.copy_jobs[0].child_jobs_in_state["CopyJobState"] #=> Integer
resp.copy_jobs[0].resource_name #=> String
resp.copy_jobs[0].message_category #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

  • :by_resource_arn (String) —

    Returns only copy jobs that match the specified resource Amazon Resource Name (ARN).

  • :by_state (String) —

    Returns only copy jobs that are in the specified state.

  • :by_created_before (Time, DateTime, Date, Integer, String) —

    Returns only copy jobs that were created before the specified date.

  • :by_created_after (Time, DateTime, Date, Integer, String) —

    Returns only copy jobs that were created after the specified date.

  • :by_resource_type (String) —

    Returns only backup jobs for the specified resources:

    • Aurora for Amazon Aurora

    • CloudFormation for CloudFormation

    • DocumentDB for Amazon DocumentDB (with MongoDB compatibility)

    • DynamoDB for Amazon DynamoDB

    • EBS for Amazon Elastic Block Store

    • EC2 for Amazon Elastic Compute Cloud

    • EFS for Amazon Elastic File System

    • FSx for Amazon FSx

    • Neptune for Amazon Neptune

    • RDS for Amazon Relational Database Service

    • Redshift for Amazon Redshift

    • S3 for Amazon Simple Storage Service (Amazon S3)

    • SAP HANA on Amazon EC2 for SAP HANA databases on Amazon Elastic Compute Cloud instances

    • Storage Gateway for Storage Gateway

    • Timestream for Amazon Timestream

    • VirtualMachine for VMware virtual machines

  • :by_destination_vault_arn (String) —

    An Amazon Resource Name (ARN) that uniquely identifies a source backup vault to copy from; for example, arn:aws:backup:us-east-1:123456789012:backup-vault:aBackupVault.

  • :by_account_id (String) —

    The account ID to list the jobs from. Returns only copy jobs associated with the specified account ID.

  • :by_complete_before (Time, DateTime, Date, Integer, String) —

    Returns only copy jobs completed before a date expressed in Unix format and Coordinated Universal Time (UTC).

  • :by_complete_after (Time, DateTime, Date, Integer, String) —

    Returns only copy jobs completed after a date expressed in Unix format and Coordinated Universal Time (UTC).

  • :by_parent_job_id (String) —

    This is a filter to list child (nested) jobs based on parent job ID.

  • :by_message_category (String) —

    This is an optional parameter that can be used to filter out jobs with a MessageCategory which matches the value you input.

    Example strings may include AccessDenied, SUCCESS, AGGREGATE_ALL, and INVALIDPARAMETERS.

    View Monitoring for a list of accepted strings.

    The the value ANY returns count of all message categories.

    AGGREGATE_ALL aggregates job counts for all message categories and returns the sum.

Returns:

See Also:



3802
3803
3804
3805
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3802

def list_copy_jobs(params = {}, options = {})
  req = build_request(:list_copy_jobs, params)
  req.send_request(options)
end

#list_frameworks(params = {}) ⇒ Types::ListFrameworksOutput

Returns a list of all frameworks for an Amazon Web Services account and Amazon Web Services Region.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_frameworks({
  max_results: 1,
  next_token: "string",
})

Response structure


resp.frameworks #=> Array
resp.frameworks[0].framework_name #=> String
resp.frameworks[0].framework_arn #=> String
resp.frameworks[0].framework_description #=> String
resp.frameworks[0].number_of_controls #=> Integer
resp.frameworks[0].creation_time #=> Time
resp.frameworks[0].deployment_status #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The number of desired results from 1 to 1000. Optional. If unspecified, the query will return 1 MB of data.

  • :next_token (String) —

    An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.

Returns:

See Also:



3848
3849
3850
3851
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3848

def list_frameworks(params = {}, options = {})
  req = build_request(:list_frameworks, params)
  req.send_request(options)
end

#list_indexed_recovery_points(params = {}) ⇒ Types::ListIndexedRecoveryPointsOutput

This operation returns a list of recovery points that have an associated index, belonging to the specified account.

Optional parameters you can include are: MaxResults; NextToken; SourceResourceArns; CreatedBefore; CreatedAfter; and ResourceType.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_indexed_recovery_points({
  next_token: "string",
  max_results: 1,
  source_resource_arn: "ARN",
  created_before: Time.now,
  created_after: Time.now,
  resource_type: "ResourceType",
  index_status: "PENDING", # accepts PENDING, ACTIVE, FAILED, DELETING
})

Response structure


resp.indexed_recovery_points #=> Array
resp.indexed_recovery_points[0].recovery_point_arn #=> String
resp.indexed_recovery_points[0].source_resource_arn #=> String
resp.indexed_recovery_points[0].iam_role_arn #=> String
resp.indexed_recovery_points[0].backup_creation_date #=> Time
resp.indexed_recovery_points[0].resource_type #=> String
resp.indexed_recovery_points[0].index_creation_date #=> Time
resp.indexed_recovery_points[0].index_status #=> String, one of "PENDING", "ACTIVE", "FAILED", "DELETING"
resp.indexed_recovery_points[0].index_status_message #=> String
resp.indexed_recovery_points[0].backup_vault_arn #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned recovery points.

    For example, if a request is made to return MaxResults number of indexed recovery points, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of resource list items to be returned.

  • :source_resource_arn (String) —

    A string of the Amazon Resource Name (ARN) that uniquely identifies the source resource.

  • :created_before (Time, DateTime, Date, Integer, String) —

    Returns only indexed recovery points that were created before the specified date.

  • :created_after (Time, DateTime, Date, Integer, String) —

    Returns only indexed recovery points that were created after the specified date.

  • :resource_type (String) —

    Returns a list of indexed recovery points for the specified resource type(s).

    Accepted values include:

    • EBS for Amazon Elastic Block Store

    • S3 for Amazon Simple Storage Service (Amazon S3)

  • :index_status (String) —

    Include this parameter to filter the returned list by the indicated statuses.

    Accepted values: PENDING | ACTIVE | FAILED | DELETING

    A recovery point with an index that has the status of ACTIVE can be included in a search.

Returns:

See Also:



3937
3938
3939
3940
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3937

def list_indexed_recovery_points(params = {}, options = {})
  req = build_request(:list_indexed_recovery_points, params)
  req.send_request(options)
end

#list_legal_holds(params = {}) ⇒ Types::ListLegalHoldsOutput

This action returns metadata about active and previous legal holds.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_legal_holds({
  next_token: "string",
  max_results: 1,
})

Response structure


resp.next_token #=> String
resp.legal_holds #=> Array
resp.legal_holds[0].title #=> String
resp.legal_holds[0].status #=> String, one of "CREATING", "ACTIVE", "CANCELING", "CANCELED"
resp.legal_holds[0].description #=> String
resp.legal_holds[0].legal_hold_id #=> String
resp.legal_holds[0].legal_hold_arn #=> String
resp.legal_holds[0].creation_date #=> Time
resp.legal_holds[0].cancellation_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned resources. For example, if a request is made to return MaxResults number of resources, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of resource list items to be returned.

Returns:

See Also:



3983
3984
3985
3986
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 3983

def list_legal_holds(params = {}, options = {})
  req = build_request(:list_legal_holds, params)
  req.send_request(options)
end

#list_protected_resources(params = {}) ⇒ Types::ListProtectedResourcesOutput

Returns an array of resources successfully backed up by Backup, including the time the resource was saved, an Amazon Resource Name (ARN) of the resource, and a resource type.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_protected_resources({
  next_token: "string",
  max_results: 1,
})

Response structure


resp.results #=> Array
resp.results[0].resource_arn #=> String
resp.results[0].resource_type #=> String
resp.results[0].last_backup_time #=> Time
resp.results[0].resource_name #=> String
resp.results[0].last_backup_vault_arn #=> String
resp.results[0].last_recovery_point_arn #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

Returns:

See Also:



4030
4031
4032
4033
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4030

def list_protected_resources(params = {}, options = {})
  req = build_request(:list_protected_resources, params)
  req.send_request(options)
end

#list_protected_resources_by_backup_vault(params = {}) ⇒ Types::ListProtectedResourcesByBackupVaultOutput

This request lists the protected resources corresponding to each backup vault.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_protected_resources_by_backup_vault({
  backup_vault_name: "BackupVaultName", # required
  backup_vault_account_id: "AccountId",
  next_token: "string",
  max_results: 1,
})

Response structure


resp.results #=> Array
resp.results[0].resource_arn #=> String
resp.results[0].resource_type #=> String
resp.results[0].last_backup_time #=> Time
resp.results[0].resource_name #=> String
resp.results[0].last_backup_vault_arn #=> String
resp.results[0].last_recovery_point_arn #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The list of protected resources by backup vault within the vault(s) you specify by name.

  • :backup_vault_account_id (String) —

    The list of protected resources by backup vault within the vault(s) you specify by account ID.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

Returns:

See Also:



4086
4087
4088
4089
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4086

def list_protected_resources_by_backup_vault(params = {}, options = {})
  req = build_request(:list_protected_resources_by_backup_vault, params)
  req.send_request(options)
end

#list_recovery_points_by_backup_vault(params = {}) ⇒ Types::ListRecoveryPointsByBackupVaultOutput

Returns detailed information about the recovery points stored in a backup vault.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_recovery_points_by_backup_vault({
  backup_vault_name: "BackupVaultName", # required
  backup_vault_account_id: "AccountId",
  next_token: "string",
  max_results: 1,
  by_resource_arn: "ARN",
  by_resource_type: "ResourceType",
  by_backup_plan_id: "string",
  by_created_before: Time.now,
  by_created_after: Time.now,
  by_parent_recovery_point_arn: "ARN",
})

Response structure


resp.next_token #=> String
resp.recovery_points #=> Array
resp.recovery_points[0].recovery_point_arn #=> String
resp.recovery_points[0].backup_vault_name #=> String
resp.recovery_points[0].backup_vault_arn #=> String
resp.recovery_points[0].source_backup_vault_arn #=> String
resp.recovery_points[0].resource_arn #=> String
resp.recovery_points[0].resource_type #=> String
resp.recovery_points[0].created_by.backup_plan_id #=> String
resp.recovery_points[0].created_by.backup_plan_arn #=> String
resp.recovery_points[0].created_by.backup_plan_version #=> String
resp.recovery_points[0].created_by.backup_rule_id #=> String
resp.recovery_points[0].iam_role_arn #=> String
resp.recovery_points[0].status #=> String, one of "COMPLETED", "PARTIAL", "DELETING", "EXPIRED"
resp.recovery_points[0].status_message #=> String
resp.recovery_points[0].creation_date #=> Time
resp.recovery_points[0].completion_date #=> Time
resp.recovery_points[0].backup_size_in_bytes #=> Integer
resp.recovery_points[0].calculated_lifecycle.move_to_cold_storage_at #=> Time
resp.recovery_points[0].calculated_lifecycle.delete_at #=> Time
resp.recovery_points[0].lifecycle.move_to_cold_storage_after_days #=> Integer
resp.recovery_points[0].lifecycle.delete_after_days #=> Integer
resp.recovery_points[0].lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.recovery_points[0].encryption_key_arn #=> String
resp.recovery_points[0].is_encrypted #=> Boolean
resp.recovery_points[0].last_restore_time #=> Time
resp.recovery_points[0].parent_recovery_point_arn #=> String
resp.recovery_points[0].composite_member_identifier #=> String
resp.recovery_points[0].is_parent #=> Boolean
resp.recovery_points[0].resource_name #=> String
resp.recovery_points[0].vault_type #=> String, one of "BACKUP_VAULT", "LOGICALLY_AIR_GAPPED_BACKUP_VAULT"
resp.recovery_points[0].index_status #=> String, one of "PENDING", "ACTIVE", "FAILED", "DELETING"
resp.recovery_points[0].index_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

    Backup vault name might not be available when a supported service creates the backup.

  • :backup_vault_account_id (String) —

    This parameter will sort the list of recovery points by account ID.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

  • :by_resource_arn (String) —

    Returns only recovery points that match the specified resource Amazon Resource Name (ARN).

  • :by_resource_type (String) —

    Returns only recovery points that match the specified resource type(s):

    • Aurora for Amazon Aurora

    • CloudFormation for CloudFormation

    • DocumentDB for Amazon DocumentDB (with MongoDB compatibility)

    • DynamoDB for Amazon DynamoDB

    • EBS for Amazon Elastic Block Store

    • EC2 for Amazon Elastic Compute Cloud

    • EFS for Amazon Elastic File System

    • FSx for Amazon FSx

    • Neptune for Amazon Neptune

    • RDS for Amazon Relational Database Service

    • Redshift for Amazon Redshift

    • S3 for Amazon Simple Storage Service (Amazon S3)

    • SAP HANA on Amazon EC2 for SAP HANA databases on Amazon Elastic Compute Cloud instances

    • Storage Gateway for Storage Gateway

    • Timestream for Amazon Timestream

    • VirtualMachine for VMware virtual machines

  • :by_backup_plan_id (String) —

    Returns only recovery points that match the specified backup plan ID.

  • :by_created_before (Time, DateTime, Date, Integer, String) —

    Returns only recovery points that were created before the specified timestamp.

  • :by_created_after (Time, DateTime, Date, Integer, String) —

    Returns only recovery points that were created after the specified timestamp.

  • :by_parent_recovery_point_arn (String) —

    This returns only recovery points that match the specified parent (composite) recovery point Amazon Resource Name (ARN).

Returns:

See Also:



4234
4235
4236
4237
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4234

def list_recovery_points_by_backup_vault(params = {}, options = {})
  req = build_request(:list_recovery_points_by_backup_vault, params)
  req.send_request(options)
end

#list_recovery_points_by_legal_hold(params = {}) ⇒ Types::ListRecoveryPointsByLegalHoldOutput

This action returns recovery point ARNs (Amazon Resource Names) of the specified legal hold.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_recovery_points_by_legal_hold({
  legal_hold_id: "string", # required
  next_token: "string",
  max_results: 1,
})

Response structure


resp.recovery_points #=> Array
resp.recovery_points[0].recovery_point_arn #=> String
resp.recovery_points[0].resource_arn #=> String
resp.recovery_points[0].resource_type #=> String
resp.recovery_points[0].backup_vault_name #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :legal_hold_id (required, String) —

    The ID of the legal hold.

  • :next_token (String) —

    The next item following a partial list of returned resources. For example, if a request is made to return MaxResults number of resources, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of resource list items to be returned.

Returns:

See Also:



4282
4283
4284
4285
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4282

def list_recovery_points_by_legal_hold(params = {}, options = {})
  req = build_request(:list_recovery_points_by_legal_hold, params)
  req.send_request(options)
end

#list_recovery_points_by_resource(params = {}) ⇒ Types::ListRecoveryPointsByResourceOutput

The information about the recovery points of the type specified by a resource Amazon Resource Name (ARN).

For Amazon EFS and Amazon EC2, this action only lists recovery points created by Backup.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_recovery_points_by_resource({
  resource_arn: "ARN", # required
  next_token: "string",
  max_results: 1,
  managed_by_aws_backup_only: false,
})

Response structure


resp.next_token #=> String
resp.recovery_points #=> Array
resp.recovery_points[0].recovery_point_arn #=> String
resp.recovery_points[0].creation_date #=> Time
resp.recovery_points[0].status #=> String, one of "COMPLETED", "PARTIAL", "DELETING", "EXPIRED"
resp.recovery_points[0].status_message #=> String
resp.recovery_points[0].encryption_key_arn #=> String
resp.recovery_points[0].backup_size_bytes #=> Integer
resp.recovery_points[0].backup_vault_name #=> String
resp.recovery_points[0].is_parent #=> Boolean
resp.recovery_points[0].parent_recovery_point_arn #=> String
resp.recovery_points[0].resource_name #=> String
resp.recovery_points[0].vault_type #=> String, one of "BACKUP_VAULT", "LOGICALLY_AIR_GAPPED_BACKUP_VAULT"
resp.recovery_points[0].index_status #=> String, one of "PENDING", "ACTIVE", "FAILED", "DELETING"
resp.recovery_points[0].index_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    An ARN that uniquely identifies a resource. The format of the ARN depends on the resource type.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

    Amazon RDS requires a value of at least 20.

  • :managed_by_aws_backup_only (Boolean) —

    This attribute filters recovery points based on ownership.

    If this is set to TRUE, the response will contain recovery points associated with the selected resources that are managed by Backup.

    If this is set to FALSE, the response will contain all recovery points associated with the selected resource.

    Type: Boolean

Returns:

See Also:



4361
4362
4363
4364
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4361

def list_recovery_points_by_resource(params = {}, options = {})
  req = build_request(:list_recovery_points_by_resource, params)
  req.send_request(options)
end

#list_report_jobs(params = {}) ⇒ Types::ListReportJobsOutput

Returns details about your report jobs.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_report_jobs({
  by_report_plan_name: "ReportPlanName",
  by_creation_before: Time.now,
  by_creation_after: Time.now,
  by_status: "string",
  max_results: 1,
  next_token: "string",
})

Response structure


resp.report_jobs #=> Array
resp.report_jobs[0].report_job_id #=> String
resp.report_jobs[0].report_plan_arn #=> String
resp.report_jobs[0].report_template #=> String
resp.report_jobs[0].creation_time #=> Time
resp.report_jobs[0].completion_time #=> Time
resp.report_jobs[0].status #=> String
resp.report_jobs[0].status_message #=> String
resp.report_jobs[0].report_destination.s3_bucket_name #=> String
resp.report_jobs[0].report_destination.s3_keys #=> Array
resp.report_jobs[0].report_destination.s3_keys[0] #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :by_report_plan_name (String) —

    Returns only report jobs with the specified report plan name.

  • :by_creation_before (Time, DateTime, Date, Integer, String) —

    Returns only report jobs that were created before the date and time specified in Unix format and Coordinated Universal Time (UTC). For example, the value 1516925490 represents Friday, January 26, 2018 12:11:30 AM.

  • :by_creation_after (Time, DateTime, Date, Integer, String) —

    Returns only report jobs that were created after the date and time specified in Unix format and Coordinated Universal Time (UTC). For example, the value 1516925490 represents Friday, January 26, 2018 12:11:30 AM.

  • :by_status (String) —

    Returns only report jobs that are in the specified status. The statuses are:

    CREATED | RUNNING | COMPLETED | FAILED

  • :max_results (Integer) —

    The number of desired results from 1 to 1000. Optional. If unspecified, the query will return 1 MB of data.

  • :next_token (String) —

    An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.

Returns:

See Also:



4435
4436
4437
4438
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4435

def list_report_jobs(params = {}, options = {})
  req = build_request(:list_report_jobs, params)
  req.send_request(options)
end

#list_report_plans(params = {}) ⇒ Types::ListReportPlansOutput

Returns a list of your report plans. For detailed information about a single report plan, use DescribeReportPlan.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_report_plans({
  max_results: 1,
  next_token: "string",
})

Response structure


resp.report_plans #=> Array
resp.report_plans[0].report_plan_arn #=> String
resp.report_plans[0].report_plan_name #=> String
resp.report_plans[0].report_plan_description #=> String
resp.report_plans[0].report_setting.report_template #=> String
resp.report_plans[0].report_setting.framework_arns #=> Array
resp.report_plans[0].report_setting.framework_arns[0] #=> String
resp.report_plans[0].report_setting.number_of_frameworks #=> Integer
resp.report_plans[0].report_setting.accounts #=> Array
resp.report_plans[0].report_setting.accounts[0] #=> String
resp.report_plans[0].report_setting.organization_units #=> Array
resp.report_plans[0].report_setting.organization_units[0] #=> String
resp.report_plans[0].report_setting.regions #=> Array
resp.report_plans[0].report_setting.regions[0] #=> String
resp.report_plans[0].report_delivery_channel.s3_bucket_name #=> String
resp.report_plans[0].report_delivery_channel.s3_key_prefix #=> String
resp.report_plans[0].report_delivery_channel.formats #=> Array
resp.report_plans[0].report_delivery_channel.formats[0] #=> String
resp.report_plans[0].deployment_status #=> String
resp.report_plans[0].creation_time #=> Time
resp.report_plans[0].last_attempted_execution_time #=> Time
resp.report_plans[0].last_successful_execution_time #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The number of desired results from 1 to 1000. Optional. If unspecified, the query will return 1 MB of data.

  • :next_token (String) —

    An identifier that was returned from the previous call to this operation, which can be used to return the next set of items in the list.

Returns:

See Also:



4496
4497
4498
4499
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4496

def list_report_plans(params = {}, options = {})
  req = build_request(:list_report_plans, params)
  req.send_request(options)
end

#list_restore_job_summaries(params = {}) ⇒ Types::ListRestoreJobSummariesOutput

This request obtains a summary of restore jobs created or running within the the most recent 30 days. You can include parameters AccountID, State, ResourceType, AggregationPeriod, MaxResults, or NextToken to filter results.

This request returns a summary that contains Region, Account, State, RestourceType, MessageCategory, StartTime, EndTime, and Count of included jobs.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_restore_job_summaries({
  account_id: "AccountId",
  state: "CREATED", # accepts CREATED, PENDING, RUNNING, ABORTED, COMPLETED, FAILED, AGGREGATE_ALL, ANY
  resource_type: "ResourceType",
  aggregation_period: "ONE_DAY", # accepts ONE_DAY, SEVEN_DAYS, FOURTEEN_DAYS
  max_results: 1,
  next_token: "string",
})

Response structure


resp.restore_job_summaries #=> Array
resp.restore_job_summaries[0].region #=> String
resp.restore_job_summaries[0]. #=> String
resp.restore_job_summaries[0].state #=> String, one of "CREATED", "PENDING", "RUNNING", "ABORTED", "COMPLETED", "FAILED", "AGGREGATE_ALL", "ANY"
resp.restore_job_summaries[0].resource_type #=> String
resp.restore_job_summaries[0].count #=> Integer
resp.restore_job_summaries[0].start_time #=> Time
resp.restore_job_summaries[0].end_time #=> Time
resp.aggregation_period #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :account_id (String) —

    Returns the job count for the specified account.

    If the request is sent from a member account or an account not part of Amazon Web Services Organizations, jobs within requestor's account will be returned.

    Root, admin, and delegated administrator accounts can use the value ANY to return job counts from every account in the organization.

    AGGREGATE_ALL aggregates job counts from all accounts within the authenticated organization, then returns the sum.

  • :state (String) —

    This parameter returns the job count for jobs with the specified state.

    The the value ANY returns count of all states.

    AGGREGATE_ALL aggregates job counts for all states and returns the sum.

  • :resource_type (String) —

    Returns the job count for the specified resource type. Use request GetSupportedResourceTypes to obtain strings for supported resource types.

    The the value ANY returns count of all resource types.

    AGGREGATE_ALL aggregates job counts for all resource types and returns the sum.

    The type of Amazon Web Services resource to be backed up; for example, an Amazon Elastic Block Store (Amazon EBS) volume or an Amazon Relational Database Service (Amazon RDS) database.

  • :aggregation_period (String) —

    The period for the returned results.

    • ONE_DAY - The daily job count for the prior 14 days.

    • SEVEN_DAYS - The aggregated job count for the prior 7 days.

    • FOURTEEN_DAYS - The aggregated job count for prior 14 days.

  • :max_results (Integer) —

    This parameter sets the maximum number of items to be returned.

    The value is an integer. Range of accepted values is from 1 to 500.

  • :next_token (String) —

    The next item following a partial list of returned resources. For example, if a request is made to return MaxResults number of resources, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

Returns:

See Also:



4602
4603
4604
4605
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4602

def list_restore_job_summaries(params = {}, options = {})
  req = build_request(:list_restore_job_summaries, params)
  req.send_request(options)
end

#list_restore_jobs(params = {}) ⇒ Types::ListRestoreJobsOutput

Returns a list of jobs that Backup initiated to restore a saved resource, including details about the recovery process.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_restore_jobs({
  next_token: "string",
  max_results: 1,
  by_account_id: "AccountId",
  by_resource_type: "ResourceType",
  by_created_before: Time.now,
  by_created_after: Time.now,
  by_status: "PENDING", # accepts PENDING, RUNNING, COMPLETED, ABORTED, FAILED
  by_complete_before: Time.now,
  by_complete_after: Time.now,
  by_restore_testing_plan_arn: "ARN",
})

Response structure


resp.restore_jobs #=> Array
resp.restore_jobs[0]. #=> String
resp.restore_jobs[0].restore_job_id #=> String
resp.restore_jobs[0].recovery_point_arn #=> String
resp.restore_jobs[0].creation_date #=> Time
resp.restore_jobs[0].completion_date #=> Time
resp.restore_jobs[0].status #=> String, one of "PENDING", "RUNNING", "COMPLETED", "ABORTED", "FAILED"
resp.restore_jobs[0].status_message #=> String
resp.restore_jobs[0].percent_done #=> String
resp.restore_jobs[0].backup_size_in_bytes #=> Integer
resp.restore_jobs[0].iam_role_arn #=> String
resp.restore_jobs[0].expected_completion_time_minutes #=> Integer
resp.restore_jobs[0].created_resource_arn #=> String
resp.restore_jobs[0].resource_type #=> String
resp.restore_jobs[0].recovery_point_creation_date #=> Time
resp.restore_jobs[0].created_by.restore_testing_plan_arn #=> String
resp.restore_jobs[0].validation_status #=> String, one of "FAILED", "SUCCESSFUL", "TIMED_OUT", "VALIDATING"
resp.restore_jobs[0].validation_status_message #=> String
resp.restore_jobs[0].deletion_status #=> String, one of "DELETING", "FAILED", "SUCCESSFUL"
resp.restore_jobs[0].deletion_status_message #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

  • :by_account_id (String) —

    The account ID to list the jobs from. Returns only restore jobs associated with the specified account ID.

  • :by_resource_type (String) —

    Include this parameter to return only restore jobs for the specified resources:

    • Aurora for Amazon Aurora

    • CloudFormation for CloudFormation

    • DocumentDB for Amazon DocumentDB (with MongoDB compatibility)

    • DynamoDB for Amazon DynamoDB

    • EBS for Amazon Elastic Block Store

    • EC2 for Amazon Elastic Compute Cloud

    • EFS for Amazon Elastic File System

    • FSx for Amazon FSx

    • Neptune for Amazon Neptune

    • RDS for Amazon Relational Database Service

    • Redshift for Amazon Redshift

    • S3 for Amazon Simple Storage Service (Amazon S3)

    • SAP HANA on Amazon EC2 for SAP HANA databases on Amazon Elastic Compute Cloud instances

    • Storage Gateway for Storage Gateway

    • Timestream for Amazon Timestream

    • VirtualMachine for VMware virtual machines

  • :by_created_before (Time, DateTime, Date, Integer, String) —

    Returns only restore jobs that were created before the specified date.

  • :by_created_after (Time, DateTime, Date, Integer, String) —

    Returns only restore jobs that were created after the specified date.

  • :by_status (String) —

    Returns only restore jobs associated with the specified job status.

  • :by_complete_before (Time, DateTime, Date, Integer, String) —

    Returns only copy jobs completed before a date expressed in Unix format and Coordinated Universal Time (UTC).

  • :by_complete_after (Time, DateTime, Date, Integer, String) —

    Returns only copy jobs completed after a date expressed in Unix format and Coordinated Universal Time (UTC).

  • :by_restore_testing_plan_arn (String) —

    This returns only restore testing jobs that match the specified resource Amazon Resource Name (ARN).

Returns:

See Also:



4731
4732
4733
4734
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4731

def list_restore_jobs(params = {}, options = {})
  req = build_request(:list_restore_jobs, params)
  req.send_request(options)
end

#list_restore_jobs_by_protected_resource(params = {}) ⇒ Types::ListRestoreJobsByProtectedResourceOutput

This returns restore jobs that contain the specified protected resource.

You must include ResourceArn. You can optionally include NextToken, ByStatus, MaxResults, ByRecoveryPointCreationDateAfter , and ByRecoveryPointCreationDateBefore.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_restore_jobs_by_protected_resource({
  resource_arn: "ARN", # required
  by_status: "PENDING", # accepts PENDING, RUNNING, COMPLETED, ABORTED, FAILED
  by_recovery_point_creation_date_after: Time.now,
  by_recovery_point_creation_date_before: Time.now,
  next_token: "string",
  max_results: 1,
})

Response structure


resp.restore_jobs #=> Array
resp.restore_jobs[0]. #=> String
resp.restore_jobs[0].restore_job_id #=> String
resp.restore_jobs[0].recovery_point_arn #=> String
resp.restore_jobs[0].creation_date #=> Time
resp.restore_jobs[0].completion_date #=> Time
resp.restore_jobs[0].status #=> String, one of "PENDING", "RUNNING", "COMPLETED", "ABORTED", "FAILED"
resp.restore_jobs[0].status_message #=> String
resp.restore_jobs[0].percent_done #=> String
resp.restore_jobs[0].backup_size_in_bytes #=> Integer
resp.restore_jobs[0].iam_role_arn #=> String
resp.restore_jobs[0].expected_completion_time_minutes #=> Integer
resp.restore_jobs[0].created_resource_arn #=> String
resp.restore_jobs[0].resource_type #=> String
resp.restore_jobs[0].recovery_point_creation_date #=> Time
resp.restore_jobs[0].created_by.restore_testing_plan_arn #=> String
resp.restore_jobs[0].validation_status #=> String, one of "FAILED", "SUCCESSFUL", "TIMED_OUT", "VALIDATING"
resp.restore_jobs[0].validation_status_message #=> String
resp.restore_jobs[0].deletion_status #=> String, one of "DELETING", "FAILED", "SUCCESSFUL"
resp.restore_jobs[0].deletion_status_message #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    Returns only restore jobs that match the specified resource Amazon Resource Name (ARN).

  • :by_status (String) —

    Returns only restore jobs associated with the specified job status.

  • :by_recovery_point_creation_date_after (Time, DateTime, Date, Integer, String) —

    Returns only restore jobs of recovery points that were created after the specified date.

  • :by_recovery_point_creation_date_before (Time, DateTime, Date, Integer, String) —

    Returns only restore jobs of recovery points that were created before the specified date.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request ismade to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

Returns:

See Also:



4814
4815
4816
4817
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4814

def list_restore_jobs_by_protected_resource(params = {}, options = {})
  req = build_request(:list_restore_jobs_by_protected_resource, params)
  req.send_request(options)
end

#list_restore_testing_plans(params = {}) ⇒ Types::ListRestoreTestingPlansOutput

Returns a list of restore testing plans.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_restore_testing_plans({
  max_results: 1,
  next_token: "String",
})

Response structure


resp.next_token #=> String
resp.restore_testing_plans #=> Array
resp.restore_testing_plans[0].creation_time #=> Time
resp.restore_testing_plans[0].last_execution_time #=> Time
resp.restore_testing_plans[0].last_update_time #=> Time
resp.restore_testing_plans[0].restore_testing_plan_arn #=> String
resp.restore_testing_plans[0].restore_testing_plan_name #=> String
resp.restore_testing_plans[0].schedule_expression #=> String
resp.restore_testing_plans[0].schedule_expression_timezone #=> String
resp.restore_testing_plans[0].start_window_hours #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of items to be returned.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the nexttoken.

Returns:

See Also:



4861
4862
4863
4864
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4861

def list_restore_testing_plans(params = {}, options = {})
  req = build_request(:list_restore_testing_plans, params)
  req.send_request(options)
end

#list_restore_testing_selections(params = {}) ⇒ Types::ListRestoreTestingSelectionsOutput

Returns a list of restore testing selections. Can be filtered by MaxResults and RestoreTestingPlanName.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_restore_testing_selections({
  max_results: 1,
  next_token: "String",
  restore_testing_plan_name: "String", # required
})

Response structure


resp.next_token #=> String
resp.restore_testing_selections #=> Array
resp.restore_testing_selections[0].creation_time #=> Time
resp.restore_testing_selections[0].iam_role_arn #=> String
resp.restore_testing_selections[0].protected_resource_type #=> String
resp.restore_testing_selections[0].restore_testing_plan_name #=> String
resp.restore_testing_selections[0].restore_testing_selection_name #=> String
resp.restore_testing_selections[0].validation_window_hours #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of items to be returned.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the nexttoken.

  • :restore_testing_plan_name (required, String) —

    Returns restore testing selections by the specified restore testing plan name.

Returns:

See Also:



4912
4913
4914
4915
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4912

def list_restore_testing_selections(params = {}, options = {})
  req = build_request(:list_restore_testing_selections, params)
  req.send_request(options)
end

#list_tags(params = {}) ⇒ Types::ListTagsOutput

Returns the tags assigned to the resource, such as a target recovery point, backup plan, or backup vault.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_tags({
  resource_arn: "ARN", # required
  next_token: "string",
  max_results: 1,
})

Response structure


resp.next_token #=> String
resp.tags #=> Hash
resp.tags["TagKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a resource. The format of the ARN depends on the type of resource. Valid targets for ListTags are recovery points, backup plans, and backup vaults.

  • :next_token (String) —

    The next item following a partial list of returned items. For example, if a request is made to return MaxResults number of items, NextToken allows you to return more items in your list starting at the location pointed to by the next token.

  • :max_results (Integer) —

    The maximum number of items to be returned.

Returns:

See Also:



4959
4960
4961
4962
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4959

def list_tags(params = {}, options = {})
  req = build_request(:list_tags, params)
  req.send_request(options)
end

#put_backup_vault_access_policy(params = {}) ⇒ Struct

Sets a resource-based policy that is used to manage access permissions on the target backup vault. Requires a backup vault name and an access policy document in JSON format.

Examples:

Request syntax with placeholder values


resp = client.put_backup_vault_access_policy({
  backup_vault_name: "BackupVaultName", # required
  policy: "IAMPolicy",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :policy (String) —

    The backup vault access policy document in JSON format.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4989
4990
4991
4992
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 4989

def put_backup_vault_access_policy(params = {}, options = {})
  req = build_request(:put_backup_vault_access_policy, params)
  req.send_request(options)
end

#put_backup_vault_lock_configuration(params = {}) ⇒ Struct

Applies Backup Vault Lock to a backup vault, preventing attempts to delete any recovery point stored in or created in a backup vault. Vault Lock also prevents attempts to update the lifecycle policy that controls the retention period of any recovery point currently stored in a backup vault. If specified, Vault Lock enforces a minimum and maximum retention period for future backup and copy jobs that target a backup vault.

Backup Vault Lock has been assessed by Cohasset Associates for use in environments that are subject to SEC 17a-4, CFTC, and FINRA regulations. For more information about how Backup Vault Lock relates to these regulations, see the Cohasset Associates Compliance Assessment.

For more information, see Backup Vault Lock.

Examples:

Request syntax with placeholder values


resp = client.put_backup_vault_lock_configuration({
  backup_vault_name: "BackupVaultName", # required
  min_retention_days: 1,
  max_retention_days: 1,
  changeable_for_days: 1,
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The Backup Vault Lock configuration that specifies the name of the backup vault it protects.

  • :min_retention_days (Integer) —

    The Backup Vault Lock configuration that specifies the minimum retention period that the vault retains its recovery points. This setting can be useful if, for example, your organization's policies require you to retain certain data for at least seven years (2555 days).

    This parameter is required when a vault lock is created through CloudFormation; otherwise, this parameter is optional. If this parameter is not specified, Vault Lock will not enforce a minimum retention period.

    If this parameter is specified, any backup or copy job to the vault must have a lifecycle policy with a retention period equal to or longer than the minimum retention period. If the job's retention period is shorter than that minimum retention period, then the vault fails that backup or copy job, and you should either modify your lifecycle settings or use a different vault. The shortest minimum retention period you can specify is 1 day. Recovery points already saved in the vault prior to Vault Lock are not affected.

  • :max_retention_days (Integer) —

    The Backup Vault Lock configuration that specifies the maximum retention period that the vault retains its recovery points. This setting can be useful if, for example, your organization's policies require you to destroy certain data after retaining it for four years (1460 days).

    If this parameter is not included, Vault Lock does not enforce a maximum retention period on the recovery points in the vault. If this parameter is included without a value, Vault Lock will not enforce a maximum retention period.

    If this parameter is specified, any backup or copy job to the vault must have a lifecycle policy with a retention period equal to or shorter than the maximum retention period. If the job's retention period is longer than that maximum retention period, then the vault fails the backup or copy job, and you should either modify your lifecycle settings or use a different vault. The longest maximum retention period you can specify is 36500 days (approximately 100 years). Recovery points already saved in the vault prior to Vault Lock are not affected.

  • :changeable_for_days (Integer) —

    The Backup Vault Lock configuration that specifies the number of days before the lock date. For example, setting ChangeableForDays to 30 on Jan. 1, 2022 at 8pm UTC will set the lock date to Jan. 31, 2022 at 8pm UTC.

    Backup enforces a 72-hour cooling-off period before Vault Lock takes effect and becomes immutable. Therefore, you must set ChangeableForDays to 3 or greater.

    Before the lock date, you can delete Vault Lock from the vault using DeleteBackupVaultLockConfiguration or change the Vault Lock configuration using PutBackupVaultLockConfiguration. On and after the lock date, the Vault Lock becomes immutable and cannot be changed or deleted.

    If this parameter is not specified, you can delete Vault Lock from the vault using DeleteBackupVaultLockConfiguration or change the Vault Lock configuration using PutBackupVaultLockConfiguration at any time.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5100
5101
5102
5103
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5100

def put_backup_vault_lock_configuration(params = {}, options = {})
  req = build_request(:put_backup_vault_lock_configuration, params)
  req.send_request(options)
end

#put_backup_vault_notifications(params = {}) ⇒ Struct

Turns on notifications on a backup vault for the specified topic and events.

Examples:

Request syntax with placeholder values


resp = client.put_backup_vault_notifications({
  backup_vault_name: "BackupVaultName", # required
  sns_topic_arn: "ARN", # required
  backup_vault_events: ["BACKUP_JOB_STARTED"], # required, accepts BACKUP_JOB_STARTED, BACKUP_JOB_COMPLETED, BACKUP_JOB_SUCCESSFUL, BACKUP_JOB_FAILED, BACKUP_JOB_EXPIRED, RESTORE_JOB_STARTED, RESTORE_JOB_COMPLETED, RESTORE_JOB_SUCCESSFUL, RESTORE_JOB_FAILED, COPY_JOB_STARTED, COPY_JOB_SUCCESSFUL, COPY_JOB_FAILED, RECOVERY_POINT_MODIFIED, BACKUP_PLAN_CREATED, BACKUP_PLAN_MODIFIED, S3_BACKUP_OBJECT_FAILED, S3_RESTORE_OBJECT_FAILED
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :sns_topic_arn (required, String) —

    The Amazon Resource Name (ARN) that specifies the topic for a backup vault’s events; for example, arn:aws:sns:us-west-2:111122223333:MyVaultTopic.

  • :backup_vault_events (required, Array<String>) —

    An array of events that indicate the status of jobs to back up resources to the backup vault.

    For common use cases and code samples, see Using Amazon SNS to track Backup events.

    The following events are supported:

    • BACKUP_JOB_STARTED | BACKUP_JOB_COMPLETED

    • COPY_JOB_STARTED | COPY_JOB_SUCCESSFUL | COPY_JOB_FAILED

    • RESTORE_JOB_STARTED | RESTORE_JOB_COMPLETED | RECOVERY_POINT_MODIFIED

    • S3_BACKUP_OBJECT_FAILED | S3_RESTORE_OBJECT_FAILED

    The list below includes both supported events and deprecated events that are no longer in use (for reference). Deprecated events do not return statuses or notifications. Refer to the list above for the supported events.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5161
5162
5163
5164
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5161

def put_backup_vault_notifications(params = {}, options = {})
  req = build_request(:put_backup_vault_notifications, params)
  req.send_request(options)
end

#put_restore_validation_result(params = {}) ⇒ Struct

This request allows you to send your independent self-run restore test validation results. RestoreJobId and ValidationStatus are required. Optionally, you can input a ValidationStatusMessage.

Examples:

Request syntax with placeholder values


resp = client.put_restore_validation_result({
  restore_job_id: "RestoreJobId", # required
  validation_status: "FAILED", # required, accepts FAILED, SUCCESSFUL, TIMED_OUT, VALIDATING
  validation_status_message: "string",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_job_id (required, String) —

    This is a unique identifier of a restore job within Backup.

  • :validation_status (required, String) —

    The status of your restore validation.

  • :validation_status_message (String) —

    This is an optional message string you can input to describe the validation status for the restore test validation.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5194
5195
5196
5197
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5194

def put_restore_validation_result(params = {}, options = {})
  req = build_request(:put_restore_validation_result, params)
  req.send_request(options)
end

#start_backup_job(params = {}) ⇒ Types::StartBackupJobOutput

Starts an on-demand backup job for the specified resource.

Examples:

Request syntax with placeholder values


resp = client.start_backup_job({
  backup_vault_name: "BackupVaultName", # required
  resource_arn: "ARN", # required
  iam_role_arn: "IAMRoleArn", # required
  idempotency_token: "string",
  start_window_minutes: 1,
  complete_window_minutes: 1,
  lifecycle: {
    move_to_cold_storage_after_days: 1,
    delete_after_days: 1,
    opt_in_to_archive_for_supported_resources: false,
  },
  recovery_point_tags: {
    "TagKey" => "TagValue",
  },
  backup_options: {
    "BackupOptionKey" => "BackupOptionValue",
  },
  index: "ENABLED", # accepts ENABLED, DISABLED
})

Response structure


resp.backup_job_id #=> String
resp.recovery_point_arn #=> String
resp.creation_date #=> Time
resp.is_parent #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :resource_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a resource. The format of the ARN depends on the resource type.

  • :iam_role_arn (required, String) —

    Specifies the IAM role ARN used to create the target recovery point; for example, arn:aws:iam::123456789012:role/S3Access.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to StartBackupJob. Retrying a successful request with the same idempotency token results in a success message with no action taken.

  • :start_window_minutes (Integer) —

    A value in minutes after a backup is scheduled before a job will be canceled if it doesn't start successfully. This value is optional, and the default is 8 hours. If this value is included, it must be at least 60 minutes to avoid errors.

    This parameter has a maximum value of 100 years (52,560,000 minutes).

    During the start window, the backup job status remains in CREATED status until it has successfully begun or until the start window time has run out. If within the start window time Backup receives an error that allows the job to be retried, Backup will automatically retry to begin the job at least every 10 minutes until the backup successfully begins (the job status changes to RUNNING) or until the job status changes to EXPIRED (which is expected to occur when the start window time is over).

  • :complete_window_minutes (Integer) —

    A value in minutes during which a successfully started backup must complete, or else Backup will cancel the job. This value is optional. This value begins counting down from when the backup was scheduled. It does not add additional time for StartWindowMinutes, or if the backup started later than scheduled.

    Like StartWindowMinutes, this parameter has a maximum value of 100 years (52,560,000 minutes).

  • :lifecycle (Types::Lifecycle) —

    The lifecycle defines when a protected resource is transitioned to cold storage and when it expires. Backup will transition and expire backups automatically according to the lifecycle that you define.

    Backups transitioned to cold storage must be stored in cold storage for a minimum of 90 days. Therefore, the “retention” setting must be 90 days greater than the “transition to cold after days” setting. The “transition to cold after days” setting cannot be changed after a backup has been transitioned to cold.

    Resource types that can transition to cold storage are listed in the Feature availability by resource table. Backup ignores this expression for other resource types.

    This parameter has a maximum value of 100 years (36,500 days).

  • :recovery_point_tags (Hash<String,String>) —

    The tags to assign to the resources.

  • :backup_options (Hash<String,String>) —

    The backup option for a selected resource. This option is only available for Windows Volume Shadow Copy Service (VSS) backup jobs.

    Valid values: Set to "WindowsVSS":"enabled" to enable the WindowsVSS backup option and create a Windows VSS backup. Set to "WindowsVSS""disabled" to create a regular backup. The WindowsVSS option is not enabled by default.

  • :index (String) —

    Include this parameter to enable index creation if your backup job has a resource type that supports backup indexes.

    Resource types that support backup indexes include:

    • EBS for Amazon Elastic Block Store

    • S3 for Amazon Simple Storage Service (Amazon S3)

    Index can have 1 of 2 possible values, either ENABLED or DISABLED.

    To create a backup index for an eligible ACTIVE recovery point that does not yet have a backup index, set value to ENABLED.

    To delete a backup index, set value to DISABLED.

Returns:

See Also:



5338
5339
5340
5341
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5338

def start_backup_job(params = {}, options = {})
  req = build_request(:start_backup_job, params)
  req.send_request(options)
end

#start_copy_job(params = {}) ⇒ Types::StartCopyJobOutput

Starts a job to create a one-time copy of the specified resource.

Does not support continuous backups.

Examples:

Request syntax with placeholder values


resp = client.start_copy_job({
  recovery_point_arn: "ARN", # required
  source_backup_vault_name: "BackupVaultName", # required
  destination_backup_vault_arn: "ARN", # required
  iam_role_arn: "IAMRoleArn", # required
  idempotency_token: "string",
  lifecycle: {
    move_to_cold_storage_after_days: 1,
    delete_after_days: 1,
    opt_in_to_archive_for_supported_resources: false,
  },
})

Response structure


resp.copy_job_id #=> String
resp.creation_date #=> Time
resp.is_parent #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :recovery_point_arn (required, String) —

    An ARN that uniquely identifies a recovery point to use for the copy job; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

  • :source_backup_vault_name (required, String) —

    The name of a logical source container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :destination_backup_vault_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a destination backup vault to copy to; for example, arn:aws:backup:us-east-1:123456789012:backup-vault:aBackupVault.

  • :iam_role_arn (required, String) —

    Specifies the IAM role ARN used to copy the target recovery point; for example, arn:aws:iam::123456789012:role/S3Access.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to StartCopyJob. Retrying a successful request with the same idempotency token results in a success message with no action taken.

  • :lifecycle (Types::Lifecycle) —

    Specifies the time period, in days, before a recovery point transitions to cold storage or is deleted.

    Backups transitioned to cold storage must be stored in cold storage for a minimum of 90 days. Therefore, on the console, the retention setting must be 90 days greater than the transition to cold after days setting. The transition to cold after days setting can't be changed after a backup has been transitioned to cold.

    Resource types that can transition to cold storage are listed in the Feature availability by resource table. Backup ignores this expression for other resource types.

    To remove the existing lifecycle and retention periods and keep your recovery points indefinitely, specify -1 for MoveToColdStorageAfterDays and DeleteAfterDays.

Returns:

See Also:



5426
5427
5428
5429
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5426

def start_copy_job(params = {}, options = {})
  req = build_request(:start_copy_job, params)
  req.send_request(options)
end

#start_report_job(params = {}) ⇒ Types::StartReportJobOutput

Starts an on-demand report job for the specified report plan.

Examples:

Request syntax with placeholder values


resp = client.start_report_job({
  report_plan_name: "ReportPlanName", # required
  idempotency_token: "string",
})

Response structure


resp.report_job_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :report_plan_name (required, String) —

    The unique name of a report plan.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to StartReportJobInput. Retrying a successful request with the same idempotency token results in a success message with no action taken.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



5464
5465
5466
5467
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5464

def start_report_job(params = {}, options = {})
  req = build_request(:start_report_job, params)
  req.send_request(options)
end

#start_restore_job(params = {}) ⇒ Types::StartRestoreJobOutput

Recovers the saved resource identified by an Amazon Resource Name (ARN).

Examples:

Request syntax with placeholder values


resp = client.start_restore_job({
  recovery_point_arn: "ARN", # required
  metadata: { # required
    "MetadataKey" => "MetadataValue",
  },
  iam_role_arn: "IAMRoleArn",
  idempotency_token: "string",
  resource_type: "ResourceType",
  copy_source_tags_to_restored_resource: false,
})

Response structure


resp.restore_job_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :recovery_point_arn (required, String) —

    An ARN that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

  • :metadata (required, Hash<String,String>) —

    A set of metadata key-value pairs.

    You can get configuration metadata about a resource at the time it was backed up by calling GetRecoveryPointRestoreMetadata. However, values in addition to those provided by GetRecoveryPointRestoreMetadata might be required to restore a resource. For example, you might need to provide a new resource name if the original already exists.

    For more information about the metadata for each resource, see the following:

  • :iam_role_arn (String) —

    The Amazon Resource Name (ARN) of the IAM role that Backup uses to create the target resource; for example: arn:aws:iam::123456789012:role/S3Access.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to StartRestoreJob. Retrying a successful request with the same idempotency token results in a success message with no action taken.

  • :resource_type (String) —

    Starts a job to restore a recovery point for one of the following resources:

    • Aurora - Amazon Aurora

    • DocumentDB - Amazon DocumentDB

    • CloudFormation - CloudFormation

    • DynamoDB - Amazon DynamoDB

    • EBS - Amazon Elastic Block Store

    • EC2 - Amazon Elastic Compute Cloud

    • EFS - Amazon Elastic File System

    • FSx - Amazon FSx

    • Neptune - Amazon Neptune

    • RDS - Amazon Relational Database Service

    • Redshift - Amazon Redshift

    • Storage Gateway - Storage Gateway

    • S3 - Amazon Simple Storage Service

    • Timestream - Amazon Timestream

    • VirtualMachine - Virtual machines

  • :copy_source_tags_to_restored_resource (Boolean) —

    This is an optional parameter. If this equals True, tags included in the backup will be copied to the restored resource.

    This can only be applied to backups created through Backup.

Returns:

See Also:



5613
5614
5615
5616
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5613

def start_restore_job(params = {}, options = {})
  req = build_request(:start_restore_job, params)
  req.send_request(options)
end

#stop_backup_job(params = {}) ⇒ Struct

Attempts to cancel a job to create a one-time backup of a resource.

This action is not supported for the following services: Amazon FSx for Windows File Server, Amazon FSx for Lustre, Amazon FSx for NetApp ONTAP, Amazon FSx for OpenZFS, Amazon DocumentDB (with MongoDB compatibility), Amazon RDS, Amazon Aurora, and Amazon Neptune.

Examples:

Request syntax with placeholder values


resp = client.stop_backup_job({
  backup_job_id: "string", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_job_id (required, String) —

    Uniquely identifies a request to Backup to back up a resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5640
5641
5642
5643
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5640

def stop_backup_job(params = {}, options = {})
  req = build_request(:stop_backup_job, params)
  req.send_request(options)
end

#tag_resource(params = {}) ⇒ Struct

Assigns a set of key-value pairs to a recovery point, backup plan, or backup vault identified by an Amazon Resource Name (ARN).

This API is supported for recovery points for resource types including Aurora, Amazon DocumentDB. Amazon EBS, Amazon FSx, Neptune, and Amazon RDS.

Examples:

Request syntax with placeholder values


resp = client.tag_resource({
  resource_arn: "ARN", # required
  tags: { # required
    "TagKey" => "TagValue",
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    An ARN that uniquely identifies a resource. The format of the ARN depends on the type of the tagged resource.

    ARNs that do not include backup are incompatible with tagging. TagResource and UntagResource with invalid ARNs will result in an error. Acceptable ARN content can include arn:aws:backup:us-east. Invalid ARN content may look like arn:aws:ec2:us-east.

  • :tags (required, Hash<String,String>) —

    Key-value pairs that are used to help organize your resources. You can assign your own metadata to the resources you create. For clarity, this is the structure to assign tags: [{"Key":"string","Value":"string"}].

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5682
5683
5684
5685
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5682

def tag_resource(params = {}, options = {})
  req = build_request(:tag_resource, params)
  req.send_request(options)
end

#untag_resource(params = {}) ⇒ Struct

Removes a set of key-value pairs from a recovery point, backup plan, or backup vault identified by an Amazon Resource Name (ARN)

This API is not supported for recovery points for resource types including Aurora, Amazon DocumentDB. Amazon EBS, Amazon FSx, Neptune, and Amazon RDS.

Examples:

Request syntax with placeholder values


resp = client.untag_resource({
  resource_arn: "ARN", # required
  tag_key_list: ["string"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    An ARN that uniquely identifies a resource. The format of the ARN depends on the type of the tagged resource.

    ARNs that do not include backup are incompatible with tagging. TagResource and UntagResource with invalid ARNs will result in an error. Acceptable ARN content can include arn:aws:backup:us-east. Invalid ARN content may look like arn:aws:ec2:us-east.

  • :tag_key_list (required, Array<String>) —

    The keys to identify which key-value tags to remove from a resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5719
5720
5721
5722
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5719

def untag_resource(params = {}, options = {})
  req = build_request(:untag_resource, params)
  req.send_request(options)
end

#update_backup_plan(params = {}) ⇒ Types::UpdateBackupPlanOutput

Updates the specified backup plan. The new version is uniquely identified by its ID.

Examples:

Request syntax with placeholder values


resp = client.update_backup_plan({
  backup_plan_id: "string", # required
  backup_plan: { # required
    backup_plan_name: "BackupPlanName", # required
    rules: [ # required
      {
        rule_name: "BackupRuleName", # required
        target_backup_vault_name: "BackupVaultName", # required
        schedule_expression: "CronExpression",
        start_window_minutes: 1,
        completion_window_minutes: 1,
        lifecycle: {
          move_to_cold_storage_after_days: 1,
          delete_after_days: 1,
          opt_in_to_archive_for_supported_resources: false,
        },
        recovery_point_tags: {
          "TagKey" => "TagValue",
        },
        copy_actions: [
          {
            lifecycle: {
              move_to_cold_storage_after_days: 1,
              delete_after_days: 1,
              opt_in_to_archive_for_supported_resources: false,
            },
            destination_backup_vault_arn: "ARN", # required
          },
        ],
        enable_continuous_backup: false,
        schedule_expression_timezone: "Timezone",
        index_actions: [
          {
            resource_types: ["ResourceType"],
          },
        ],
      },
    ],
    advanced_backup_settings: [
      {
        resource_type: "ResourceType",
        backup_options: {
          "BackupOptionKey" => "BackupOptionValue",
        },
      },
    ],
  },
})

Response structure


resp.backup_plan_id #=> String
resp.backup_plan_arn #=> String
resp.creation_date #=> Time
resp.version_id #=> String
resp.advanced_backup_settings #=> Array
resp.advanced_backup_settings[0].resource_type #=> String
resp.advanced_backup_settings[0].backup_options #=> Hash
resp.advanced_backup_settings[0].backup_options["BackupOptionKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_plan_id (required, String) —

    The ID of the backup plan.

  • :backup_plan (required, Types::BackupPlanInput) —

    The body of a backup plan. Includes a BackupPlanName and one or more sets of Rules.

Returns:

See Also:



5808
5809
5810
5811
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5808

def update_backup_plan(params = {}, options = {})
  req = build_request(:update_backup_plan, params)
  req.send_request(options)
end

#update_framework(params = {}) ⇒ Types::UpdateFrameworkOutput

Updates the specified framework.

Examples:

Request syntax with placeholder values


resp = client.update_framework({
  framework_name: "FrameworkName", # required
  framework_description: "FrameworkDescription",
  framework_controls: [
    {
      control_name: "ControlName", # required
      control_input_parameters: [
        {
          parameter_name: "ParameterName",
          parameter_value: "ParameterValue",
        },
      ],
      control_scope: {
        compliance_resource_ids: ["string"],
        compliance_resource_types: ["ARN"],
        tags: {
          "string" => "string",
        },
      },
    },
  ],
  idempotency_token: "string",
})

Response structure


resp.framework_name #=> String
resp.framework_arn #=> String
resp.creation_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :framework_name (required, String) —

    The unique name of a framework. This name is between 1 and 256 characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers (0-9), and underscores (_).

  • :framework_description (String) —

    An optional description of the framework with a maximum 1,024 characters.

  • :framework_controls (Array<Types::FrameworkControl>) —

    The controls that make up the framework. Each control in the list has a name, input parameters, and scope.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to UpdateFrameworkInput. Retrying a successful request with the same idempotency token results in a success message with no action taken.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



5879
5880
5881
5882
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5879

def update_framework(params = {}, options = {})
  req = build_request(:update_framework, params)
  req.send_request(options)
end

#update_global_settings(params = {}) ⇒ Struct

Updates whether the Amazon Web Services account is opted in to cross-account backup. Returns an error if the account is not an Organizations management account. Use the DescribeGlobalSettings API to determine the current settings.

Examples:

Request syntax with placeholder values


resp = client.update_global_settings({
  global_settings: {
    "GlobalSettingsName" => "GlobalSettingsValue",
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :global_settings (Hash<String,String>) —

    A value for isCrossAccountBackupEnabled and a Region. Example: update-global-settings --global-settings isCrossAccountBackupEnabled=false --region us-west-2.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



5908
5909
5910
5911
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5908

def update_global_settings(params = {}, options = {})
  req = build_request(:update_global_settings, params)
  req.send_request(options)
end

#update_recovery_point_index_settings(params = {}) ⇒ Types::UpdateRecoveryPointIndexSettingsOutput

This operation updates the settings of a recovery point index.

Required: BackupVaultName, RecoveryPointArn, and IAMRoleArn

Examples:

Request syntax with placeholder values


resp = client.update_recovery_point_index_settings({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
  iam_role_arn: "IAMRoleArn",
  index: "ENABLED", # required, accepts ENABLED, DISABLED
})

Response structure


resp.backup_vault_name #=> String
resp.recovery_point_arn #=> String
resp.index_status #=> String, one of "PENDING", "ACTIVE", "FAILED", "DELETING"
resp.index #=> String, one of "ENABLED", "DISABLED"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Region where they are created.

    Accepted characters include lowercase letters, numbers, and hyphens.

  • :recovery_point_arn (required, String) —

    An ARN that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

  • :iam_role_arn (String) —

    This specifies the IAM role ARN used for this operation.

    For example, arn:aws:iam::123456789012:role/S3Access

  • :index (required, String) —

    Index can have 1 of 2 possible values, either ENABLED or DISABLED.

    To create a backup index for an eligible ACTIVE recovery point that does not yet have a backup index, set value to ENABLED.

    To delete a backup index, set value to DISABLED.

Returns:

See Also:



5968
5969
5970
5971
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 5968

def update_recovery_point_index_settings(params = {}, options = {})
  req = build_request(:update_recovery_point_index_settings, params)
  req.send_request(options)
end

#update_recovery_point_lifecycle(params = {}) ⇒ Types::UpdateRecoveryPointLifecycleOutput

Sets the transition lifecycle of a recovery point.

The lifecycle defines when a protected resource is transitioned to cold storage and when it expires. Backup transitions and expires backups automatically according to the lifecycle that you define.

Resource types that can transition to cold storage are listed in the Feature availability by resource table. Backup ignores this expression for other resource types.

Backups transitioned to cold storage must be stored in cold storage for a minimum of 90 days. Therefore, the “retention” setting must be 90 days greater than the “transition to cold after days” setting. The “transition to cold after days” setting cannot be changed after a backup has been transitioned to cold.

If your lifecycle currently uses the parameters DeleteAfterDays and MoveToColdStorageAfterDays, include these parameters and their values when you call this operation. Not including them may result in your plan updating with null values.

This operation does not support continuous backups.

Examples:

Request syntax with placeholder values


resp = client.update_recovery_point_lifecycle({
  backup_vault_name: "BackupVaultName", # required
  recovery_point_arn: "ARN", # required
  lifecycle: {
    move_to_cold_storage_after_days: 1,
    delete_after_days: 1,
    opt_in_to_archive_for_supported_resources: false,
  },
})

Response structure


resp.backup_vault_arn #=> String
resp.recovery_point_arn #=> String
resp.lifecycle.move_to_cold_storage_after_days #=> Integer
resp.lifecycle.delete_after_days #=> Integer
resp.lifecycle.opt_in_to_archive_for_supported_resources #=> Boolean
resp.calculated_lifecycle.move_to_cold_storage_at #=> Time
resp.calculated_lifecycle.delete_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :backup_vault_name (required, String) —

    The name of a logical container where backups are stored. Backup vaults are identified by names that are unique to the account used to create them and the Amazon Web Services Region where they are created.

  • :recovery_point_arn (required, String) —

    An Amazon Resource Name (ARN) that uniquely identifies a recovery point; for example, arn:aws:backup:us-east-1:123456789012:recovery-point:1EB3B5E7-9EB0-435A-A80B-108B488B0D45.

  • :lifecycle (Types::Lifecycle) —

    The lifecycle defines when a protected resource is transitioned to cold storage and when it expires. Backup transitions and expires backups automatically according to the lifecycle that you define.

    Backups transitioned to cold storage must be stored in cold storage for a minimum of 90 days. Therefore, the “retention” setting must be 90 days greater than the “transition to cold after days” setting. The “transition to cold after days” setting cannot be changed after a backup has been transitioned to cold.

Returns:

See Also:



6054
6055
6056
6057
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 6054

def update_recovery_point_lifecycle(params = {}, options = {})
  req = build_request(:update_recovery_point_lifecycle, params)
  req.send_request(options)
end

#update_region_settings(params = {}) ⇒ Struct

Updates the current service opt-in settings for the Region.

Use the DescribeRegionSettings API to determine the resource types that are supported.

Examples:

Request syntax with placeholder values


resp = client.update_region_settings({
  resource_type_opt_in_preference: {
    "ResourceType" => false,
  },
  resource_type_management_preference: {
    "ResourceType" => false,
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_type_opt_in_preference (Hash<String,Boolean>) —

    Updates the list of services along with the opt-in preferences for the Region.

    If resource assignments are only based on tags, then service opt-in settings are applied. If a resource type is explicitly assigned to a backup plan, such as Amazon S3, Amazon EC2, or Amazon RDS, it will be included in the backup even if the opt-in is not enabled for that particular service. If both a resource type and tags are specified in a resource assignment, the resource type specified in the backup plan takes priority over the tag condition. Service opt-in settings are disregarded in this situation.

  • :resource_type_management_preference (Hash<String,Boolean>) —

    Enables or disables full Backup management of backups for a resource type. To enable full Backup management for DynamoDB along with Backup's advanced DynamoDB backup features, follow the procedure to enable advanced DynamoDB backup programmatically.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



6105
6106
6107
6108
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 6105

def update_region_settings(params = {}, options = {})
  req = build_request(:update_region_settings, params)
  req.send_request(options)
end

#update_report_plan(params = {}) ⇒ Types::UpdateReportPlanOutput

Updates the specified report plan.

Examples:

Request syntax with placeholder values


resp = client.update_report_plan({
  report_plan_name: "ReportPlanName", # required
  report_plan_description: "ReportPlanDescription",
  report_delivery_channel: {
    s3_bucket_name: "string", # required
    s3_key_prefix: "string",
    formats: ["string"],
  },
  report_setting: {
    report_template: "string", # required
    framework_arns: ["string"],
    number_of_frameworks: 1,
    accounts: ["string"],
    organization_units: ["string"],
    regions: ["string"],
  },
  idempotency_token: "string",
})

Response structure


resp.report_plan_name #=> String
resp.report_plan_arn #=> String
resp.creation_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :report_plan_name (required, String) —

    The unique name of the report plan. This name is between 1 and 256 characters, starting with a letter, and consisting of letters (a-z, A-Z), numbers (0-9), and underscores (_).

  • :report_plan_description (String) —

    An optional description of the report plan with a maximum 1,024 characters.

  • :report_delivery_channel (Types::ReportDeliveryChannel) —

    The information about where to deliver your reports, specifically your Amazon S3 bucket name, S3 key prefix, and the formats of your reports.

  • :report_setting (Types::ReportSetting) —

    The report template for the report. Reports are built using a report template. The report templates are:

    RESOURCE_COMPLIANCE_REPORT | CONTROL_COMPLIANCE_REPORT | BACKUP_JOB_REPORT | COPY_JOB_REPORT | RESTORE_JOB_REPORT

    If the report template is RESOURCE_COMPLIANCE_REPORT or CONTROL_COMPLIANCE_REPORT, this API resource also describes the report coverage by Amazon Web Services Regions and frameworks.

  • :idempotency_token (String) —

    A customer-chosen string that you can use to distinguish between otherwise identical calls to UpdateReportPlanInput. Retrying a successful request with the same idempotency token results in a success message with no action taken.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

See Also:



6182
6183
6184
6185
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 6182

def update_report_plan(params = {}, options = {})
  req = build_request(:update_report_plan, params)
  req.send_request(options)
end

#update_restore_testing_plan(params = {}) ⇒ Types::UpdateRestoreTestingPlanOutput

This request will send changes to your specified restore testing plan. RestoreTestingPlanName cannot be updated after it is created.

RecoveryPointSelection can contain:

  • Algorithm

  • ExcludeVaults

  • IncludeVaults

  • RecoveryPointTypes

  • SelectionWindowDays

Examples:

Request syntax with placeholder values


resp = client.update_restore_testing_plan({
  restore_testing_plan: { # required
    recovery_point_selection: {
      algorithm: "LATEST_WITHIN_WINDOW", # accepts LATEST_WITHIN_WINDOW, RANDOM_WITHIN_WINDOW
      exclude_vaults: ["string"],
      include_vaults: ["string"],
      recovery_point_types: ["CONTINUOUS"], # accepts CONTINUOUS, SNAPSHOT
      selection_window_days: 1,
    },
    schedule_expression: "String",
    schedule_expression_timezone: "String",
    start_window_hours: 1,
  },
  restore_testing_plan_name: "String", # required
})

Response structure


resp.creation_time #=> Time
resp.restore_testing_plan_arn #=> String
resp.restore_testing_plan_name #=> String
resp.update_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_testing_plan (required, Types::RestoreTestingPlanForUpdate) —

    Specifies the body of a restore testing plan.

  • :restore_testing_plan_name (required, String) —

    The name of the restore testing plan name.

Returns:

See Also:



6244
6245
6246
6247
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 6244

def update_restore_testing_plan(params = {}, options = {})
  req = build_request(:update_restore_testing_plan, params)
  req.send_request(options)
end

#update_restore_testing_selection(params = {}) ⇒ Types::UpdateRestoreTestingSelectionOutput

Updates the specified restore testing selection.

Most elements except the RestoreTestingSelectionName can be updated with this request.

You can use either protected resource ARNs or conditions, but not both.

Examples:

Request syntax with placeholder values


resp = client.update_restore_testing_selection({
  restore_testing_plan_name: "String", # required
  restore_testing_selection: { # required
    iam_role_arn: "String",
    protected_resource_arns: ["string"],
    protected_resource_conditions: {
      string_equals: [
        {
          key: "String", # required
          value: "String", # required
        },
      ],
      string_not_equals: [
        {
          key: "String", # required
          value: "String", # required
        },
      ],
    },
    restore_metadata_overrides: {
      "String" => "String",
    },
    validation_window_hours: 1,
  },
  restore_testing_selection_name: "String", # required
})

Response structure


resp.creation_time #=> Time
resp.restore_testing_plan_arn #=> String
resp.restore_testing_plan_name #=> String
resp.restore_testing_selection_name #=> String
resp.update_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :restore_testing_plan_name (required, String) —

    The restore testing plan name is required to update the indicated testing plan.

  • :restore_testing_selection (required, Types::RestoreTestingSelectionForUpdate) —

    To update your restore testing selection, you can use either protected resource ARNs or conditions, but not both. That is, if your selection has ProtectedResourceArns, requesting an update with the parameter ProtectedResourceConditions will be unsuccessful.

  • :restore_testing_selection_name (required, String) —

    The required restore testing selection name of the restore testing selection you wish to update.

Returns:

See Also:



6320
6321
6322
6323
 
# File 'gems/aws-sdk-backup/lib/aws-sdk-backup/client.rb', line 6320

def update_restore_testing_selection(params = {}, options = {})
  req = build_request(:update_restore_testing_selection, params)
  req.send_request(options)
end