Class: Aws::S3Control::Client

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

Overview

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

client = Aws::S3Control::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):

  • :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, and :session_token options.
    • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
    • ~/.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::InstanceProfileCredentails or Aws::ECSCredentials to enable retries and extended timeouts.
  • :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)
  • :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.

  • :disable_host_prefix_injection (Boolean) — default: false —

    Set to true to disable SDK automatically adding host prefix to default service endpoint when available.

  • :endpoint (String) —

    The client endpoint is normally constructed from the :region option. You should only configure an :endpoint when connecting to test or custom endpoints. This should be a valid HTTP(S) URI.

  • :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.

  • :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.

  • :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.

  • :s3_use_arn_region (Boolean) — default: true —

    For S3 and S3 Outposts ARNs passed into the :bucket or :name parameter, this option will use the region in the ARN, allowing for cross-region requests to be made. Set to false to use the client's region instead.

  • :secret_access_key (String)
  • :session_token (String)
  • :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.

  • :use_dualstack_endpoint (Boolean) — default: false —

    When set to true, IPv6-compatible bucket endpoints will be used for all operations.

  • :validate_params (Boolean) — default: true —

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

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

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

  • :http_open_timeout (Float) — default: 15 —

    The number of seconds to wait when opening a HTTP session before raising a Timeout::Error.

  • :http_read_timeout (Integer) — default: 60 —

    The default number of seconds to wait for response data. 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_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_wire_trace (Boolean) — default: false —

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

  • :ssl_verify_peer (Boolean) — default: true —

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

  • :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.



340
341
342
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 340

def initialize(*args)
  super
end

Instance Method Details

#create_access_point(params = {}) ⇒ Types::CreateAccessPointResult

Creates an access point and associates it with the specified bucket. For more information, see Managing Data Access with Amazon S3 Access Points in the Amazon S3 User Guide.

S3 on Outposts only supports VPC-style access points.

For more information, see Accessing Amazon S3 on Outposts using virtual private cloud (VPC) only access points in the Amazon S3 User Guide.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to CreateAccessPoint:

Examples:

Request syntax with placeholder values


resp = client.create_access_point({
  account_id: "AccountId", # required
  name: "AccessPointName", # required
  bucket: "BucketName", # required
  vpc_configuration: {
    vpc_id: "VpcId", # required
  },
  public_access_block_configuration: {
    block_public_acls: false,
    ignore_public_acls: false,
    block_public_policy: false,
    restrict_public_buckets: false,
  },
})

Response structure


resp.access_point_arn #=> String
resp.alias #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the bucket for which you want to create an access point.

  • :name (required, String) —

    The name you want to assign to this access point.

  • :bucket (required, String) —

    The name of the bucket that you want to associate this access point with.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

  • :vpc_configuration (Types::VpcConfiguration) —

    If you include this field, Amazon S3 restricts access to this access point to requests from the specified virtual private cloud (VPC).

    This is required for creating an access point for Amazon S3 on Outposts buckets.

  • :public_access_block_configuration (Types::PublicAccessBlockConfiguration) —

    The PublicAccessBlock configuration that you want to apply to the access point.

Returns:

See Also:



455
456
457
458
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 455

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

#create_access_point_for_object_lambda(params = {}) ⇒ Types::CreateAccessPointForObjectLambdaResult

Creates an Object Lambda Access Point. For more information, see Transforming objects with Object Lambda Access Points in the Amazon S3 User Guide.

The following actions are related to CreateAccessPointForObjectLambda:

Examples:

Request syntax with placeholder values


resp = client.create_access_point_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
  configuration: { # required
    supporting_access_point: "ObjectLambdaSupportingAccessPointArn", # required
    cloud_watch_metrics_enabled: false,
    allowed_features: ["GetObject-Range"], # accepts GetObject-Range, GetObject-PartNumber
    transformation_configurations: [ # required
      {
        actions: ["GetObject"], # required, accepts GetObject
        content_transformation: { # required
          aws_lambda: {
            function_arn: "FunctionArnString", # required
            function_payload: "AwsLambdaTransformationPayload",
          },
        },
      },
    ],
  },
})

Response structure


resp.object_lambda_access_point_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for owner of the specified Object Lambda Access Point.

  • :name (required, String) —

    The name you want to assign to this Object Lambda Access Point.

  • :configuration (required, Types::ObjectLambdaConfiguration) —

    Object Lambda Access Point configuration as a JSON document.

Returns:

See Also:



525
526
527
528
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 525

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

#create_bucket(params = {}) ⇒ Types::CreateBucketResult

This action creates an Amazon S3 on Outposts bucket. To create an S3 bucket, see Create Bucket in the Amazon S3 API Reference.

Creates a new Outposts bucket. By creating the bucket, you become the bucket owner. To create an Outposts bucket, you must have S3 on Outposts. For more information, see Using Amazon S3 on Outposts in Amazon S3 User Guide.

Not every string is an acceptable bucket name. For information on bucket naming restrictions, see Working with Amazon S3 Buckets.

S3 on Outposts buckets support:

  • Tags

  • LifecycleConfigurations for deleting expired objects

For a complete list of restrictions and Amazon S3 feature limitations on S3 on Outposts, see Amazon S3 on Outposts Restrictions and Limitations.

For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and x-amz-outpost-id in your API request, see the Examples section.

The following actions are related to CreateBucket for Amazon S3 on Outposts:

Examples:

Request syntax with placeholder values


resp = client.create_bucket({
  acl: "private", # accepts private, public-read, public-read-write, authenticated-read
  bucket: "BucketName", # required
  create_bucket_configuration: {
    location_constraint: "EU", # accepts EU, eu-west-1, us-west-1, us-west-2, ap-south-1, ap-southeast-1, ap-southeast-2, ap-northeast-1, sa-east-1, cn-north-1, eu-central-1
  },
  grant_full_control: "GrantFullControl",
  grant_read: "GrantRead",
  grant_read_acp: "GrantReadACP",
  grant_write: "GrantWrite",
  grant_write_acp: "GrantWriteACP",
  object_lock_enabled_for_bucket: false,
  outpost_id: "NonEmptyMaxLength64String",
})

Response structure


resp.location #=> String
resp.bucket_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :acl (String) —

    The canned ACL to apply to the bucket.

    This is not supported by Amazon S3 on Outposts buckets.

  • :bucket (required, String) —

    The name of the bucket.

  • :create_bucket_configuration (Types::CreateBucketConfiguration) —

    The configuration information for the bucket.

    This is not supported by Amazon S3 on Outposts buckets.

  • :grant_full_control (String) —

    Allows grantee the read, write, read ACP, and write ACP permissions on the bucket.

    This is not supported by Amazon S3 on Outposts buckets.

  • :grant_read (String) —

    Allows grantee to list the objects in the bucket.

    This is not supported by Amazon S3 on Outposts buckets.

  • :grant_read_acp (String) —

    Allows grantee to read the bucket ACL.

    This is not supported by Amazon S3 on Outposts buckets.

  • :grant_write (String) —

    Allows grantee to create, overwrite, and delete any object in the bucket.

    This is not supported by Amazon S3 on Outposts buckets.

  • :grant_write_acp (String) —

    Allows grantee to write the ACL for the applicable bucket.

    This is not supported by Amazon S3 on Outposts buckets.

  • :object_lock_enabled_for_bucket (Boolean) —

    Specifies whether you want S3 Object Lock to be enabled for the new bucket.

    This is not supported by Amazon S3 on Outposts buckets.

  • :outpost_id (String) —

    The ID of the Outposts where the bucket is being created.

    This is required by Amazon S3 on Outposts buckets.

Returns:

See Also:



683
684
685
686
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 683

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

#create_job(params = {}) ⇒ Types::CreateJobResult

You can use S3 Batch Operations to perform large-scale batch actions on Amazon S3 objects. Batch Operations can run a single action on lists of Amazon S3 objects that you specify. For more information, see S3 Batch Operations in the Amazon S3 User Guide.

This action creates a S3 Batch Operations job.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.create_job({
  account_id: "AccountId", # required
  confirmation_required: false,
  operation: { # required
    lambda_invoke: {
      function_arn: "FunctionArnString",
    },
    s3_put_object_copy: {
      target_resource: "S3BucketArnString",
      canned_access_control_list: "private", # accepts private, public-read, public-read-write, aws-exec-read, authenticated-read, bucket-owner-read, bucket-owner-full-control
      access_control_grants: [
        {
          grantee: {
            type_identifier: "id", # accepts id, emailAddress, uri
            identifier: "NonEmptyMaxLength1024String",
            display_name: "NonEmptyMaxLength1024String",
          },
          permission: "FULL_CONTROL", # accepts FULL_CONTROL, READ, WRITE, READ_ACP, WRITE_ACP
        },
      ],
      metadata_directive: "COPY", # accepts COPY, REPLACE
      modified_since_constraint: Time.now,
      new_object_metadata: {
        cache_control: "NonEmptyMaxLength1024String",
        content_disposition: "NonEmptyMaxLength1024String",
        content_encoding: "NonEmptyMaxLength1024String",
        content_language: "NonEmptyMaxLength1024String",
        user_metadata: {
          "NonEmptyMaxLength1024String" => "MaxLength1024String",
        },
        content_length: 1,
        content_md5: "NonEmptyMaxLength1024String",
        content_type: "NonEmptyMaxLength1024String",
        http_expires_date: Time.now,
        requester_charged: false,
        sse_algorithm: "AES256", # accepts AES256, KMS
      },
      new_object_tagging: [
        {
          key: "TagKeyString", # required
          value: "TagValueString", # required
        },
      ],
      redirect_location: "NonEmptyMaxLength2048String",
      requester_pays: false,
      storage_class: "STANDARD", # accepts STANDARD, STANDARD_IA, ONEZONE_IA, GLACIER, INTELLIGENT_TIERING, DEEP_ARCHIVE
      un_modified_since_constraint: Time.now,
      sse_aws_kms_key_id: "KmsKeyArnString",
      target_key_prefix: "NonEmptyMaxLength1024String",
      object_lock_legal_hold_status: "OFF", # accepts OFF, ON
      object_lock_mode: "COMPLIANCE", # accepts COMPLIANCE, GOVERNANCE
      object_lock_retain_until_date: Time.now,
      bucket_key_enabled: false,
    },
    s3_put_object_acl: {
      access_control_policy: {
        access_control_list: {
          owner: { # required
            id: "NonEmptyMaxLength1024String",
            display_name: "NonEmptyMaxLength1024String",
          },
          grants: [
            {
              grantee: {
                type_identifier: "id", # accepts id, emailAddress, uri
                identifier: "NonEmptyMaxLength1024String",
                display_name: "NonEmptyMaxLength1024String",
              },
              permission: "FULL_CONTROL", # accepts FULL_CONTROL, READ, WRITE, READ_ACP, WRITE_ACP
            },
          ],
        },
        canned_access_control_list: "private", # accepts private, public-read, public-read-write, aws-exec-read, authenticated-read, bucket-owner-read, bucket-owner-full-control
      },
    },
    s3_put_object_tagging: {
      tag_set: [
        {
          key: "TagKeyString", # required
          value: "TagValueString", # required
        },
      ],
    },
    s3_delete_object_tagging: {
    },
    s3_initiate_restore_object: {
      expiration_in_days: 1,
      glacier_job_tier: "BULK", # accepts BULK, STANDARD
    },
    s3_put_object_legal_hold: {
      legal_hold: { # required
        status: "OFF", # required, accepts OFF, ON
      },
    },
    s3_put_object_retention: {
      bypass_governance_retention: false,
      retention: { # required
        retain_until_date: Time.now,
        mode: "COMPLIANCE", # accepts COMPLIANCE, GOVERNANCE
      },
    },
  },
  report: { # required
    bucket: "S3BucketArnString",
    format: "Report_CSV_20180820", # accepts Report_CSV_20180820
    enabled: false, # required
    prefix: "ReportPrefixString",
    report_scope: "AllTasks", # accepts AllTasks, FailedTasksOnly
  },
  client_request_token: "NonEmptyMaxLength64String", # required
  manifest: { # required
    spec: { # required
      format: "S3BatchOperations_CSV_20180820", # required, accepts S3BatchOperations_CSV_20180820, S3InventoryReport_CSV_20161130
      fields: ["Ignore"], # accepts Ignore, Bucket, Key, VersionId
    },
    location: { # required
      object_arn: "S3KeyArnString", # required
      object_version_id: "S3ObjectVersionId",
      etag: "NonEmptyMaxLength1024String", # required
    },
  },
  description: "NonEmptyMaxLength256String",
  priority: 1, # required
  role_arn: "IAMRoleArn", # required
  tags: [
    {
      key: "TagKeyString", # required
      value: "TagValueString", # required
    },
  ],
})

Response structure


resp.job_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID that creates the job.

  • :confirmation_required (Boolean) —

    Indicates whether confirmation is required before Amazon S3 runs the job. Confirmation is only required for jobs created through the Amazon S3 console.

  • :operation (required, Types::JobOperation) —

    The action that you want this job to perform on every object listed in the manifest. For more information about the available actions, see Operations in the Amazon S3 User Guide.

  • :report (required, Types::JobReport) —

    Configuration parameters for the optional job-completion report.

  • :client_request_token (required, String) —

    An idempotency token to ensure that you don't accidentally submit the same request twice. You can use any string up to the maximum length.

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

  • :manifest (required, Types::JobManifest) —

    Configuration parameters for the manifest.

  • :description (String) —

    A description for this job. You can use any string within the permitted length. Descriptions don't need to be unique and can be used for multiple jobs.

  • :priority (required, Integer) —

    The numerical priority for this job. Higher numbers indicate higher priority.

  • :role_arn (required, String) —

    The Amazon Resource Name (ARN) for the Identity and Access Management (IAM) role that Batch Operations will use to run this job's action on every object in the manifest.

  • :tags (Array<Types::S3Tag>) —

    A set of tags to associate with the S3 Batch Operations job. This is an optional parameter.

Returns:

See Also:



912
913
914
915
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 912

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

#create_multi_region_access_point(params = {}) ⇒ Types::CreateMultiRegionAccessPointResult

Creates a Multi-Region Access Point and associates it with the specified buckets. For more information about creating Multi-Region Access Points, see Creating Multi-Region Access Points in the Amazon S3 User Guide.

This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around managing Multi-Region Access Points, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

This request is asynchronous, meaning that you might receive a response before the command has completed. When this request provides a response, it provides a token that you can use to monitor the status of the request with DescribeMultiRegionAccessPointOperation.

The following actions are related to CreateMultiRegionAccessPoint:

Examples:

Request syntax with placeholder values


resp = client.create_multi_region_access_point({
  account_id: "AccountId", # required
  client_token: "MultiRegionAccessPointClientToken", # required
  details: { # required
    name: "MultiRegionAccessPointName", # required
    public_access_block: {
      block_public_acls: false,
      ignore_public_acls: false,
      block_public_policy: false,
      restrict_public_buckets: false,
    },
    regions: [ # required
      {
        bucket: "BucketName", # required
      },
    ],
  },
})

Response structure


resp.request_token_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point. The owner of the Multi-Region Access Point also must own the underlying buckets.

  • :client_token (required, String) —

    An idempotency token used to identify the request and guarantee that requests are unique.

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

  • :details (required, Types::CreateMultiRegionAccessPointInput) —

    A container element containing details about the Multi-Region Access Point.

Returns:

See Also:



1000
1001
1002
1003
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1000

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

#delete_access_point(params = {}) ⇒ Struct

Deletes the specified access point.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to DeleteAccessPoint:

Examples:

Request syntax with placeholder values


resp = client.delete_access_point({
  account_id: "AccountId", # required
  name: "AccessPointName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified access point.

  • :name (required, String) —

    The name of the access point you want to delete.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the access point accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint/<my-accesspoint-name>. For example, to access the access point reports-ap through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap. The value must be URL encoded.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1062
1063
1064
1065
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1062

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

#delete_access_point_for_object_lambda(params = {}) ⇒ Struct

Deletes the specified Object Lambda Access Point.

The following actions are related to DeleteAccessPointForObjectLambda:

Examples:

Request syntax with placeholder values


resp = client.delete_access_point_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the access point you want to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1104
1105
1106
1107
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1104

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

#delete_access_point_policy(params = {}) ⇒ Struct

Deletes the access point policy for the specified access point.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to DeleteAccessPointPolicy:

Examples:

Request syntax with placeholder values


resp = client.delete_access_point_policy({
  account_id: "AccountId", # required
  name: "AccessPointName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified access point.

  • :name (required, String) —

    The name of the access point whose policy you want to delete.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the access point accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint/<my-accesspoint-name>. For example, to access the access point reports-ap through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap. The value must be URL encoded.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1165
1166
1167
1168
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1165

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

#delete_access_point_policy_for_object_lambda(params = {}) ⇒ Struct

Removes the resource policy for an Object Lambda Access Point.

The following actions are related to DeleteAccessPointPolicyForObjectLambda:

Examples:

Request syntax with placeholder values


resp = client.delete_access_point_policy_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the Object Lambda Access Point you want to delete the policy for.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1205
1206
1207
1208
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1205

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

#delete_bucket(params = {}) ⇒ Struct

This action deletes an Amazon S3 on Outposts bucket. To delete an S3 bucket, see DeleteBucket in the Amazon S3 API Reference.

Deletes the Amazon S3 on Outposts bucket. All objects (including all object versions and delete markers) in the bucket must be deleted before the bucket itself can be deleted. For more information, see Using Amazon S3 on Outposts in Amazon S3 User Guide.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

Related Resources

Examples:

Request syntax with placeholder values


resp = client.delete_bucket({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID that owns the Outposts bucket.

  • :bucket (required, String) —

    Specifies the bucket being deleted.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



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

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

#delete_bucket_lifecycle_configuration(params = {}) ⇒ Struct

This action deletes an Amazon S3 on Outposts bucket's lifecycle configuration. To delete an S3 bucket's lifecycle configuration, see DeleteBucketLifecycle in the Amazon S3 API Reference.

Deletes the lifecycle configuration from the specified Outposts bucket. Amazon S3 on Outposts removes all the lifecycle configuration rules in the lifecycle subresource associated with the bucket. Your objects never expire, and Amazon S3 on Outposts no longer automatically deletes any objects on the basis of rules contained in the deleted lifecycle configuration. For more information, see Using Amazon S3 on Outposts in Amazon S3 User Guide.

To use this action, you must have permission to perform the s3-outposts:DeleteLifecycleConfiguration action. By default, the bucket owner has this permission and the Outposts bucket owner can grant this permission to others.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

For more information about object expiration, see Elements to Describe Lifecycle Actions.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.delete_bucket_lifecycle_configuration({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID of the lifecycle configuration to delete.

  • :bucket (required, String) —

    Specifies the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1359
1360
1361
1362
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1359

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

#delete_bucket_policy(params = {}) ⇒ Struct

This action deletes an Amazon S3 on Outposts bucket policy. To delete an S3 bucket policy, see DeleteBucketPolicy in the Amazon S3 API Reference.

This implementation of the DELETE action uses the policy subresource to delete the policy of a specified Amazon S3 on Outposts bucket. If you are using an identity other than the root user of the Amazon Web Services account that owns the bucket, the calling identity must have the s3-outposts:DeleteBucketPolicy permissions on the specified Outposts bucket and belong to the bucket owner's account to use this action. For more information, see Using Amazon S3 on Outposts in Amazon S3 User Guide.

If you don't have DeleteBucketPolicy permissions, Amazon S3 returns a 403 Access Denied error. If you have the correct permissions, but you're not using an identity that belongs to the bucket owner's account, Amazon S3 returns a 405 Method Not Allowed error.

As a security precaution, the root user of the Amazon Web Services account that owns a bucket can always use this action, even if the policy explicitly denies the root user the ability to perform this action.

For more information about bucket policies, see Using Bucket Policies and User Policies.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to DeleteBucketPolicy:

Examples:

Request syntax with placeholder values


resp = client.delete_bucket_policy({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID of the Outposts bucket.

  • :bucket (required, String) —

    Specifies the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1447
1448
1449
1450
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1447

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

#delete_bucket_tagging(params = {}) ⇒ Struct

This action deletes an Amazon S3 on Outposts bucket's tags. To delete an S3 bucket tags, see DeleteBucketTagging in the Amazon S3 API Reference.

Deletes the tags from the Outposts bucket. For more information, see Using Amazon S3 on Outposts in Amazon S3 User Guide.

To use this action, you must have permission to perform the PutBucketTagging action. By default, the bucket owner has this permission and can grant this permission to others.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to DeleteBucketTagging:

Examples:

Request syntax with placeholder values


resp = client.delete_bucket_tagging({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket tag set to be removed.

  • :bucket (required, String) —

    The bucket ARN that has the tag set to be removed.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1520
1521
1522
1523
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1520

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

#delete_job_tagging(params = {}) ⇒ Struct

Removes the entire tag set from the specified S3 Batch Operations job. To use this operation, you must have permission to perform the s3:DeleteJobTagging action. For more information, see Controlling access and labeling jobs using tags in the Amazon S3 User Guide.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.delete_job_tagging({
  account_id: "AccountId", # required
  job_id: "JobId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID associated with the S3 Batch Operations job.

  • :job_id (required, String) —

    The ID for the S3 Batch Operations job whose tags you want to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1567
1568
1569
1570
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1567

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

#delete_multi_region_access_point(params = {}) ⇒ Types::DeleteMultiRegionAccessPointResult

Deletes a Multi-Region Access Point. This action does not delete the buckets associated with the Multi-Region Access Point, only the Multi-Region Access Point itself.

This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around managing Multi-Region Access Points, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

This request is asynchronous, meaning that you might receive a response before the command has completed. When this request provides a response, it provides a token that you can use to monitor the status of the request with DescribeMultiRegionAccessPointOperation.

The following actions are related to DeleteMultiRegionAccessPoint:

Examples:

Request syntax with placeholder values


resp = client.delete_multi_region_access_point({
  account_id: "AccountId", # required
  client_token: "MultiRegionAccessPointClientToken", # required
  details: { # required
    name: "MultiRegionAccessPointName", # required
  },
})

Response structure


resp.request_token_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point.

  • :client_token (required, String) —

    An idempotency token used to identify the request and guarantee that requests are unique.

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

  • :details (required, Types::DeleteMultiRegionAccessPointInput) —

    A container element containing details about the Multi-Region Access Point.

Returns:

See Also:



1641
1642
1643
1644
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1641

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

#delete_public_access_block(params = {}) ⇒ Struct

Removes the PublicAccessBlock configuration for an Amazon Web Services account. For more information, see Using Amazon S3 block public access.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.delete_public_access_block({
  account_id: "AccountId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the Amazon Web Services account whose PublicAccessBlock configuration you want to remove.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1678
1679
1680
1681
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1678

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

#delete_storage_lens_configuration(params = {}) ⇒ Struct

Deletes the Amazon S3 Storage Lens configuration. For more information about S3 Storage Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens in the Amazon S3 User Guide.

To use this action, you must have permission to perform the s3:DeleteStorageLensConfiguration action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the Amazon S3 User Guide.

Examples:

Request syntax with placeholder values


resp = client.delete_storage_lens_configuration({
  config_id: "ConfigId", # required
  account_id: "AccountId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :config_id (required, String) —

    The ID of the S3 Storage Lens configuration.

  • :account_id (required, String) —

    The account ID of the requester.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1718
1719
1720
1721
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1718

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

#delete_storage_lens_configuration_tagging(params = {}) ⇒ Struct

Deletes the Amazon S3 Storage Lens configuration tags. For more information about S3 Storage Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens in the Amazon S3 User Guide.

To use this action, you must have permission to perform the s3:DeleteStorageLensConfigurationTagging action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the Amazon S3 User Guide.

Examples:

Request syntax with placeholder values


resp = client.delete_storage_lens_configuration_tagging({
  config_id: "ConfigId", # required
  account_id: "AccountId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :config_id (required, String) —

    The ID of the S3 Storage Lens configuration.

  • :account_id (required, String) —

    The account ID of the requester.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



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

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

#describe_job(params = {}) ⇒ Types::DescribeJobResult

Retrieves the configuration parameters and status for a Batch Operations job. For more information, see S3 Batch Operations in the Amazon S3 User Guide.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.describe_job({
  account_id: "AccountId", # required
  job_id: "JobId", # required
})

Response structure


resp.job.job_id #=> String
resp.job.confirmation_required #=> Boolean
resp.job.description #=> String
resp.job.job_arn #=> String
resp.job.status #=> String, one of "Active", "Cancelled", "Cancelling", "Complete", "Completing", "Failed", "Failing", "New", "Paused", "Pausing", "Preparing", "Ready", "Suspended"
resp.job.manifest.spec.format #=> String, one of "S3BatchOperations_CSV_20180820", "S3InventoryReport_CSV_20161130"
resp.job.manifest.spec.fields #=> Array
resp.job.manifest.spec.fields[0] #=> String, one of "Ignore", "Bucket", "Key", "VersionId"
resp.job.manifest.location.object_arn #=> String
resp.job.manifest.location.object_version_id #=> String
resp.job.manifest.location.etag #=> String
resp.job.operation.lambda_invoke.function_arn #=> String
resp.job.operation.s3_put_object_copy.target_resource #=> String
resp.job.operation.s3_put_object_copy.canned_access_control_list #=> String, one of "private", "public-read", "public-read-write", "aws-exec-read", "authenticated-read", "bucket-owner-read", "bucket-owner-full-control"
resp.job.operation.s3_put_object_copy.access_control_grants #=> Array
resp.job.operation.s3_put_object_copy.access_control_grants[0].grantee.type_identifier #=> String, one of "id", "emailAddress", "uri"
resp.job.operation.s3_put_object_copy.access_control_grants[0].grantee.identifier #=> String
resp.job.operation.s3_put_object_copy.access_control_grants[0].grantee.display_name #=> String
resp.job.operation.s3_put_object_copy.access_control_grants[0].permission #=> String, one of "FULL_CONTROL", "READ", "WRITE", "READ_ACP", "WRITE_ACP"
resp.job.operation.s3_put_object_copy.metadata_directive #=> String, one of "COPY", "REPLACE"
resp.job.operation.s3_put_object_copy.modified_since_constraint #=> Time
resp.job.operation.s3_put_object_copy.new_object_metadata.cache_control #=> String
resp.job.operation.s3_put_object_copy.new_object_metadata.content_disposition #=> String
resp.job.operation.s3_put_object_copy.new_object_metadata.content_encoding #=> String
resp.job.operation.s3_put_object_copy.new_object_metadata.content_language #=> String
resp.job.operation.s3_put_object_copy.new_object_metadata.user_metadata #=> Hash
resp.job.operation.s3_put_object_copy.new_object_metadata.user_metadata["NonEmptyMaxLength1024String"] #=> String
resp.job.operation.s3_put_object_copy.new_object_metadata.content_length #=> Integer
resp.job.operation.s3_put_object_copy.new_object_metadata.content_md5 #=> String
resp.job.operation.s3_put_object_copy.new_object_metadata.content_type #=> String
resp.job.operation.s3_put_object_copy.new_object_metadata.http_expires_date #=> Time
resp.job.operation.s3_put_object_copy.new_object_metadata.requester_charged #=> Boolean
resp.job.operation.s3_put_object_copy.new_object_metadata.sse_algorithm #=> String, one of "AES256", "KMS"
resp.job.operation.s3_put_object_copy.new_object_tagging #=> Array
resp.job.operation.s3_put_object_copy.new_object_tagging[0].key #=> String
resp.job.operation.s3_put_object_copy.new_object_tagging[0].value #=> String
resp.job.operation.s3_put_object_copy.redirect_location #=> String
resp.job.operation.s3_put_object_copy.requester_pays #=> Boolean
resp.job.operation.s3_put_object_copy.storage_class #=> String, one of "STANDARD", "STANDARD_IA", "ONEZONE_IA", "GLACIER", "INTELLIGENT_TIERING", "DEEP_ARCHIVE"
resp.job.operation.s3_put_object_copy.un_modified_since_constraint #=> Time
resp.job.operation.s3_put_object_copy.sse_aws_kms_key_id #=> String
resp.job.operation.s3_put_object_copy.target_key_prefix #=> String
resp.job.operation.s3_put_object_copy.object_lock_legal_hold_status #=> String, one of "OFF", "ON"
resp.job.operation.s3_put_object_copy.object_lock_mode #=> String, one of "COMPLIANCE", "GOVERNANCE"
resp.job.operation.s3_put_object_copy.object_lock_retain_until_date #=> Time
resp.job.operation.s3_put_object_copy.bucket_key_enabled #=> Boolean
resp.job.operation.s3_put_object_acl.access_control_policy.access_control_list.owner.id #=> String
resp.job.operation.s3_put_object_acl.access_control_policy.access_control_list.owner.display_name #=> String
resp.job.operation.s3_put_object_acl.access_control_policy.access_control_list.grants #=> Array
resp.job.operation.s3_put_object_acl.access_control_policy.access_control_list.grants[0].grantee.type_identifier #=> String, one of "id", "emailAddress", "uri"
resp.job.operation.s3_put_object_acl.access_control_policy.access_control_list.grants[0].grantee.identifier #=> String
resp.job.operation.s3_put_object_acl.access_control_policy.access_control_list.grants[0].grantee.display_name #=> String
resp.job.operation.s3_put_object_acl.access_control_policy.access_control_list.grants[0].permission #=> String, one of "FULL_CONTROL", "READ", "WRITE", "READ_ACP", "WRITE_ACP"
resp.job.operation.s3_put_object_acl.access_control_policy.canned_access_control_list #=> String, one of "private", "public-read", "public-read-write", "aws-exec-read", "authenticated-read", "bucket-owner-read", "bucket-owner-full-control"
resp.job.operation.s3_put_object_tagging.tag_set #=> Array
resp.job.operation.s3_put_object_tagging.tag_set[0].key #=> String
resp.job.operation.s3_put_object_tagging.tag_set[0].value #=> String
resp.job.operation.s3_initiate_restore_object.expiration_in_days #=> Integer
resp.job.operation.s3_initiate_restore_object.glacier_job_tier #=> String, one of "BULK", "STANDARD"
resp.job.operation.s3_put_object_legal_hold.legal_hold.status #=> String, one of "OFF", "ON"
resp.job.operation.s3_put_object_retention.bypass_governance_retention #=> Boolean
resp.job.operation.s3_put_object_retention.retention.retain_until_date #=> Time
resp.job.operation.s3_put_object_retention.retention.mode #=> String, one of "COMPLIANCE", "GOVERNANCE"
resp.job.priority #=> Integer
resp.job.progress_summary.total_number_of_tasks #=> Integer
resp.job.progress_summary.number_of_tasks_succeeded #=> Integer
resp.job.progress_summary.number_of_tasks_failed #=> Integer
resp.job.status_update_reason #=> String
resp.job.failure_reasons #=> Array
resp.job.failure_reasons[0].failure_code #=> String
resp.job.failure_reasons[0].failure_reason #=> String
resp.job.report.bucket #=> String
resp.job.report.format #=> String, one of "Report_CSV_20180820"
resp.job.report.enabled #=> Boolean
resp.job.report.prefix #=> String
resp.job.report.report_scope #=> String, one of "AllTasks", "FailedTasksOnly"
resp.job.creation_time #=> Time
resp.job.termination_date #=> Time
resp.job.role_arn #=> String
resp.job.suspended_date #=> Time
resp.job.suspended_cause #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID associated with the S3 Batch Operations job.

  • :job_id (required, String) —

    The ID for the job whose information you want to retrieve.

Returns:

See Also:



1894
1895
1896
1897
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1894

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

#describe_multi_region_access_point_operation(params = {}) ⇒ Types::DescribeMultiRegionAccessPointOperationResult

Retrieves the status of an asynchronous request to manage a Multi-Region Access Point. For more information about managing Multi-Region Access Points and how asynchronous requests work, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

The following actions are related to GetMultiRegionAccessPoint:

Examples:

Request syntax with placeholder values


resp = client.describe_multi_region_access_point_operation({
  account_id: "AccountId", # required
  request_token_arn: "AsyncRequestTokenARN", # required
})

Response structure


resp.async_operation.creation_time #=> Time
resp.async_operation.operation #=> String, one of "CreateMultiRegionAccessPoint", "DeleteMultiRegionAccessPoint", "PutMultiRegionAccessPointPolicy"
resp.async_operation.request_token_arn #=> String
resp.async_operation.request_parameters.create_multi_region_access_point_request.name #=> String
resp.async_operation.request_parameters.create_multi_region_access_point_request.public_access_block.block_public_acls #=> Boolean
resp.async_operation.request_parameters.create_multi_region_access_point_request.public_access_block.ignore_public_acls #=> Boolean
resp.async_operation.request_parameters.create_multi_region_access_point_request.public_access_block.block_public_policy #=> Boolean
resp.async_operation.request_parameters.create_multi_region_access_point_request.public_access_block.restrict_public_buckets #=> Boolean
resp.async_operation.request_parameters.create_multi_region_access_point_request.regions #=> Array
resp.async_operation.request_parameters.create_multi_region_access_point_request.regions[0].bucket #=> String
resp.async_operation.request_parameters.delete_multi_region_access_point_request.name #=> String
resp.async_operation.request_parameters.put_multi_region_access_point_policy_request.name #=> String
resp.async_operation.request_parameters.put_multi_region_access_point_policy_request.policy #=> String
resp.async_operation.request_status #=> String
resp.async_operation.response_details.multi_region_access_point_details.regions #=> Array
resp.async_operation.response_details.multi_region_access_point_details.regions[0].name #=> String
resp.async_operation.response_details.multi_region_access_point_details.regions[0].request_status #=> String
resp.async_operation.response_details.error_details.code #=> String
resp.async_operation.response_details.error_details.message #=> String
resp.async_operation.response_details.error_details.resource #=> String
resp.async_operation.response_details.error_details.request_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point.

  • :request_token_arn (required, String) —

    The request token associated with the request you want to know about. This request token is returned as part of the response when you make an asynchronous request. You provide this token to query about the status of the asynchronous action.

Returns:

See Also:



1972
1973
1974
1975
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 1972

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

#get_access_point(params = {}) ⇒ Types::GetAccessPointResult

Returns configuration information about the specified access point.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to GetAccessPoint:

Examples:

Request syntax with placeholder values


resp = client.get_access_point({
  account_id: "AccountId", # required
  name: "AccessPointName", # required
})

Response structure


resp.name #=> String
resp.bucket #=> String
resp.network_origin #=> String, one of "Internet", "VPC"
resp.vpc_configuration.vpc_id #=> String
resp.public_access_block_configuration.block_public_acls #=> Boolean
resp.public_access_block_configuration.ignore_public_acls #=> Boolean
resp.public_access_block_configuration.block_public_policy #=> Boolean
resp.public_access_block_configuration.restrict_public_buckets #=> Boolean
resp.creation_date #=> Time
resp.alias #=> String
resp.access_point_arn #=> String
resp.endpoints #=> Hash
resp.endpoints["NonEmptyMaxLength64String"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified access point.

  • :name (required, String) —

    The name of the access point whose configuration information you want to retrieve.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the access point accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint/<my-accesspoint-name>. For example, to access the access point reports-ap through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap. The value must be URL encoded.

Returns:

See Also:



2063
2064
2065
2066
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2063

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

#get_access_point_configuration_for_object_lambda(params = {}) ⇒ Types::GetAccessPointConfigurationForObjectLambdaResult

Returns configuration for an Object Lambda Access Point.

The following actions are related to GetAccessPointConfigurationForObjectLambda:

^

Examples:

Request syntax with placeholder values


resp = client.get_access_point_configuration_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
})

Response structure


resp.configuration.supporting_access_point #=> String
resp.configuration.cloud_watch_metrics_enabled #=> Boolean
resp.configuration.allowed_features #=> Array
resp.configuration.allowed_features[0] #=> String, one of "GetObject-Range", "GetObject-PartNumber"
resp.configuration.transformation_configurations #=> Array
resp.configuration.transformation_configurations[0].actions #=> Array
resp.configuration.transformation_configurations[0].actions[0] #=> String, one of "GetObject"
resp.configuration.transformation_configurations[0].content_transformation.aws_lambda.function_arn #=> String
resp.configuration.transformation_configurations[0].content_transformation.aws_lambda.function_payload #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the Object Lambda Access Point you want to return the configuration for.

Returns:

See Also:



2116
2117
2118
2119
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2116

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

#get_access_point_for_object_lambda(params = {}) ⇒ Types::GetAccessPointForObjectLambdaResult

Returns configuration information about the specified Object Lambda Access Point

The following actions are related to GetAccessPointForObjectLambda:

Examples:

Request syntax with placeholder values


resp = client.get_access_point_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
})

Response structure


resp.name #=> String
resp.public_access_block_configuration.block_public_acls #=> Boolean
resp.public_access_block_configuration.ignore_public_acls #=> Boolean
resp.public_access_block_configuration.block_public_policy #=> Boolean
resp.public_access_block_configuration.restrict_public_buckets #=> Boolean
resp.creation_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the Object Lambda Access Point.

Returns:

See Also:



2171
2172
2173
2174
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2171

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

#get_access_point_policy(params = {}) ⇒ Types::GetAccessPointPolicyResult

Returns the access point policy associated with the specified access point.

The following actions are related to GetAccessPointPolicy:

Examples:

Request syntax with placeholder values


resp = client.get_access_point_policy({
  account_id: "AccountId", # required
  name: "AccessPointName", # required
})

Response structure


resp.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified access point.

  • :name (required, String) —

    The name of the access point whose policy you want to retrieve.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the access point accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint/<my-accesspoint-name>. For example, to access the access point reports-ap through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap. The value must be URL encoded.

Returns:

See Also:



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

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

#get_access_point_policy_for_object_lambda(params = {}) ⇒ Types::GetAccessPointPolicyForObjectLambdaResult

Returns the resource policy for an Object Lambda Access Point.

The following actions are related to GetAccessPointPolicyForObjectLambda:

Examples:

Request syntax with placeholder values


resp = client.get_access_point_policy_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
})

Response structure


resp.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the Object Lambda Access Point.

Returns:

See Also:



2273
2274
2275
2276
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2273

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

#get_access_point_policy_status(params = {}) ⇒ Types::GetAccessPointPolicyStatusResult

Indicates whether the specified access point currently has a policy that allows public access. For more information about public access through access points, see Managing Data Access with Amazon S3 access points in the Amazon S3 User Guide.

Examples:

Request syntax with placeholder values


resp = client.get_access_point_policy_status({
  account_id: "AccountId", # required
  name: "AccessPointName", # required
})

Response structure


resp.policy_status.is_public #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified access point.

  • :name (required, String) —

    The name of the access point whose policy status you want to retrieve.

Returns:

See Also:



2312
2313
2314
2315
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2312

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

#get_access_point_policy_status_for_object_lambda(params = {}) ⇒ Types::GetAccessPointPolicyStatusForObjectLambdaResult

Returns the status of the resource policy associated with an Object Lambda Access Point.

Examples:

Request syntax with placeholder values


resp = client.get_access_point_policy_status_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
})

Response structure


resp.policy_status.is_public #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the Object Lambda Access Point.

Returns:

See Also:



2346
2347
2348
2349
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2346

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

#get_bucket(params = {}) ⇒ Types::GetBucketResult

Gets an Amazon S3 on Outposts bucket. For more information, see Using Amazon S3 on Outposts in the Amazon S3 User Guide.

If you are using an identity other than the root user of the Amazon Web Services account that owns the Outposts bucket, the calling identity must have the s3-outposts:GetBucket permissions on the specified Outposts bucket and belong to the Outposts bucket owner's account in order to use this action. Only users from Outposts bucket owner account with the right permissions can perform actions on an Outposts bucket.

If you don't have s3-outposts:GetBucket permissions or you're not using an identity that belongs to the bucket owner's account, Amazon S3 returns a 403 Access Denied error.

The following actions are related to GetBucket for Amazon S3 on Outposts:

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

Examples:

Request syntax with placeholder values


resp = client.get_bucket({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Response structure


resp.bucket #=> String
resp.public_access_block_enabled #=> Boolean
resp.creation_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :bucket (required, String) —

    Specifies the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

See Also:



2433
2434
2435
2436
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2433

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

#get_bucket_lifecycle_configuration(params = {}) ⇒ Types::GetBucketLifecycleConfigurationResult

This action gets an Amazon S3 on Outposts bucket's lifecycle configuration. To get an S3 bucket's lifecycle configuration, see GetBucketLifecycleConfiguration in the Amazon S3 API Reference.

Returns the lifecycle configuration information set on the Outposts bucket. For more information, see Using Amazon S3 on Outposts and for information about lifecycle configuration, see Object Lifecycle Management in Amazon S3 User Guide.

To use this action, you must have permission to perform the s3-outposts:GetLifecycleConfiguration action. The Outposts bucket owner has this permission, by default. The bucket owner can grant this permission to others. For more information about permissions, see Permissions Related to Bucket Subresource Operations and Managing Access Permissions to Your Amazon S3 Resources.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

GetBucketLifecycleConfiguration has the following special error:

  • Error code: NoSuchLifecycleConfiguration

    • Description: The lifecycle configuration does not exist.

    • HTTP Status Code: 404 Not Found

    • SOAP Fault Code Prefix: Client

The following actions are related to GetBucketLifecycleConfiguration:

Examples:

Request syntax with placeholder values


resp = client.get_bucket_lifecycle_configuration({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Response structure


resp.rules #=> Array
resp.rules[0].expiration.date #=> Time
resp.rules[0].expiration.days #=> Integer
resp.rules[0].expiration.expired_object_delete_marker #=> Boolean
resp.rules[0].id #=> String
resp.rules[0].filter.prefix #=> String
resp.rules[0].filter.tag.key #=> String
resp.rules[0].filter.tag.value #=> String
resp.rules[0].filter.and.prefix #=> String
resp.rules[0].filter.and.tags #=> Array
resp.rules[0].filter.and.tags[0].key #=> String
resp.rules[0].filter.and.tags[0].value #=> String
resp.rules[0].status #=> String, one of "Enabled", "Disabled"
resp.rules[0].transitions #=> Array
resp.rules[0].transitions[0].date #=> Time
resp.rules[0].transitions[0].days #=> Integer
resp.rules[0].transitions[0].storage_class #=> String, one of "GLACIER", "STANDARD_IA", "ONEZONE_IA", "INTELLIGENT_TIERING", "DEEP_ARCHIVE"
resp.rules[0].noncurrent_version_transitions #=> Array
resp.rules[0].noncurrent_version_transitions[0].noncurrent_days #=> Integer
resp.rules[0].noncurrent_version_transitions[0].storage_class #=> String, one of "GLACIER", "STANDARD_IA", "ONEZONE_IA", "INTELLIGENT_TIERING", "DEEP_ARCHIVE"
resp.rules[0].noncurrent_version_expiration.noncurrent_days #=> Integer
resp.rules[0].abort_incomplete_multipart_upload.days_after_initiation #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :bucket (required, String) —

    The Amazon Resource Name (ARN) of the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

See Also:



2551
2552
2553
2554
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2551

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

#get_bucket_policy(params = {}) ⇒ Types::GetBucketPolicyResult

This action gets a bucket policy for an Amazon S3 on Outposts bucket. To get a policy for an S3 bucket, see GetBucketPolicy in the Amazon S3 API Reference.

Returns the policy of a specified Outposts bucket. For more information, see Using Amazon S3 on Outposts in the Amazon S3 User Guide.

If you are using an identity other than the root user of the Amazon Web Services account that owns the bucket, the calling identity must have the GetBucketPolicy permissions on the specified bucket and belong to the bucket owner's account in order to use this action.

Only users from Outposts bucket owner account with the right permissions can perform actions on an Outposts bucket. If you don't have s3-outposts:GetBucketPolicy permissions or you're not using an identity that belongs to the bucket owner's account, Amazon S3 returns a 403 Access Denied error.

As a security precaution, the root user of the Amazon Web Services account that owns a bucket can always use this action, even if the policy explicitly denies the root user the ability to perform this action.

For more information about bucket policies, see Using Bucket Policies and User Policies.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to GetBucketPolicy:

Examples:

Request syntax with placeholder values


resp = client.get_bucket_policy({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Response structure


resp.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :bucket (required, String) —

    Specifies the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

See Also:



2649
2650
2651
2652
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2649

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

#get_bucket_tagging(params = {}) ⇒ Types::GetBucketTaggingResult

This action gets an Amazon S3 on Outposts bucket's tags. To get an S3 bucket tags, see GetBucketTagging in the Amazon S3 API Reference.

Returns the tag set associated with the Outposts bucket. For more information, see Using Amazon S3 on Outposts in the Amazon S3 User Guide.

To use this action, you must have permission to perform the GetBucketTagging action. By default, the bucket owner has this permission and can grant this permission to others.

GetBucketTagging has the following special error:

  • Error code: NoSuchTagSetError

    • Description: There is no tag set associated with the bucket.

    ^

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to GetBucketTagging:

Examples:

Request syntax with placeholder values


resp = client.get_bucket_tagging({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
})

Response structure


resp.tag_set #=> Array
resp.tag_set[0].key #=> String
resp.tag_set[0].value #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :bucket (required, String) —

    Specifies the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

Returns:

See Also:



2738
2739
2740
2741
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2738

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

#get_job_tagging(params = {}) ⇒ Types::GetJobTaggingResult

Returns the tags on an S3 Batch Operations job. To use this operation, you must have permission to perform the s3:GetJobTagging action. For more information, see Controlling access and labeling jobs using tags in the Amazon S3 User Guide.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.get_job_tagging({
  account_id: "AccountId", # required
  job_id: "JobId", # required
})

Response structure


resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID associated with the S3 Batch Operations job.

  • :job_id (required, String) —

    The ID for the S3 Batch Operations job whose tags you want to retrieve.

Returns:

See Also:



2794
2795
2796
2797
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2794

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

#get_multi_region_access_point(params = {}) ⇒ Types::GetMultiRegionAccessPointResult

Returns configuration information about the specified Multi-Region Access Point.

This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around managing Multi-Region Access Points, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

The following actions are related to GetMultiRegionAccessPoint:

Examples:

Request syntax with placeholder values


resp = client.get_multi_region_access_point({
  account_id: "AccountId", # required
  name: "MultiRegionAccessPointName", # required
})

Response structure


resp.access_point.name #=> String
resp.access_point.alias #=> String
resp.access_point.created_at #=> Time
resp.access_point.public_access_block.block_public_acls #=> Boolean
resp.access_point.public_access_block.ignore_public_acls #=> Boolean
resp.access_point.public_access_block.block_public_policy #=> Boolean
resp.access_point.public_access_block.restrict_public_buckets #=> Boolean
resp.access_point.status #=> String, one of "READY", "INCONSISTENT_ACROSS_REGIONS", "CREATING", "PARTIALLY_CREATED", "PARTIALLY_DELETED", "DELETING"
resp.access_point.regions #=> Array
resp.access_point.regions[0].bucket #=> String
resp.access_point.regions[0].region #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point.

  • :name (required, String) —

    The name of the Multi-Region Access Point whose configuration information you want to receive. The name of the Multi-Region Access Point is different from the alias. For more information about the distinction between the name and the alias of an Multi-Region Access Point, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

Returns:

See Also:



2870
2871
2872
2873
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2870

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

#get_multi_region_access_point_policy(params = {}) ⇒ Types::GetMultiRegionAccessPointPolicyResult

Returns the access control policy of the specified Multi-Region Access Point.

This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around managing Multi-Region Access Points, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

The following actions are related to GetMultiRegionAccessPointPolicy:

Examples:

Request syntax with placeholder values


resp = client.get_multi_region_access_point_policy({
  account_id: "AccountId", # required
  name: "MultiRegionAccessPointName", # required
})

Response structure


resp.policy.established.policy #=> String
resp.policy.proposed.policy #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point.

  • :name (required, String) —

    Specifies the Multi-Region Access Point. The name of the Multi-Region Access Point is different from the alias. For more information about the distinction between the name and the alias of an Multi-Region Access Point, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

Returns:

See Also:



2931
2932
2933
2934
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2931

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

#get_multi_region_access_point_policy_status(params = {}) ⇒ Types::GetMultiRegionAccessPointPolicyStatusResult

Indicates whether the specified Multi-Region Access Point has an access control policy that allows public access.

This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around managing Multi-Region Access Points, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

The following actions are related to GetMultiRegionAccessPointPolicyStatus:

Examples:

Request syntax with placeholder values


resp = client.get_multi_region_access_point_policy_status({
  account_id: "AccountId", # required
  name: "MultiRegionAccessPointName", # required
})

Response structure


resp.established.is_public #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point.

  • :name (required, String) —

    Specifies the Multi-Region Access Point. The name of the Multi-Region Access Point is different from the alias. For more information about the distinction between the name and the alias of an Multi-Region Access Point, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

Returns:

See Also:



2991
2992
2993
2994
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 2991

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

#get_public_access_block(params = {}) ⇒ Types::GetPublicAccessBlockOutput

Retrieves the PublicAccessBlock configuration for an Amazon Web Services account. For more information, see Using Amazon S3 block public access.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.get_public_access_block({
  account_id: "AccountId", # required
})

Response structure


resp.public_access_block_configuration.block_public_acls #=> Boolean
resp.public_access_block_configuration.ignore_public_acls #=> Boolean
resp.public_access_block_configuration.block_public_policy #=> Boolean
resp.public_access_block_configuration.restrict_public_buckets #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the Amazon Web Services account whose PublicAccessBlock configuration you want to retrieve.

Returns:

See Also:



3037
3038
3039
3040
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3037

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

#get_storage_lens_configuration(params = {}) ⇒ Types::GetStorageLensConfigurationResult

Gets the Amazon S3 Storage Lens configuration. For more information, see Assessing your storage activity and usage with Amazon S3 Storage Lens in the Amazon S3 User Guide.

To use this action, you must have permission to perform the s3:GetStorageLensConfiguration action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the Amazon S3 User Guide.

Examples:

Request syntax with placeholder values


resp = client.get_storage_lens_configuration({
  config_id: "ConfigId", # required
  account_id: "AccountId", # required
})

Response structure


resp.storage_lens_configuration.id #=> String
resp.storage_lens_configuration..activity_metrics.is_enabled #=> Boolean
resp.storage_lens_configuration..bucket_level.activity_metrics.is_enabled #=> Boolean
resp.storage_lens_configuration..bucket_level.prefix_level.storage_metrics.is_enabled #=> Boolean
resp.storage_lens_configuration..bucket_level.prefix_level.storage_metrics.selection_criteria.delimiter #=> String
resp.storage_lens_configuration..bucket_level.prefix_level.storage_metrics.selection_criteria.max_depth #=> Integer
resp.storage_lens_configuration..bucket_level.prefix_level.storage_metrics.selection_criteria.min_storage_bytes_percentage #=> Float
resp.storage_lens_configuration.include.buckets #=> Array
resp.storage_lens_configuration.include.buckets[0] #=> String
resp.storage_lens_configuration.include.regions #=> Array
resp.storage_lens_configuration.include.regions[0] #=> String
resp.storage_lens_configuration.exclude.buckets #=> Array
resp.storage_lens_configuration.exclude.buckets[0] #=> String
resp.storage_lens_configuration.exclude.regions #=> Array
resp.storage_lens_configuration.exclude.regions[0] #=> String
resp.storage_lens_configuration.data_export.s3_bucket_destination.format #=> String, one of "CSV", "Parquet"
resp.storage_lens_configuration.data_export.s3_bucket_destination.output_schema_version #=> String, one of "V_1"
resp.storage_lens_configuration.data_export.s3_bucket_destination. #=> String
resp.storage_lens_configuration.data_export.s3_bucket_destination.arn #=> String
resp.storage_lens_configuration.data_export.s3_bucket_destination.prefix #=> String
resp.storage_lens_configuration.data_export.s3_bucket_destination.encryption.ssekms.key_id #=> String
resp.storage_lens_configuration.is_enabled #=> Boolean
resp.storage_lens_configuration.aws_org.arn #=> String
resp.storage_lens_configuration.storage_lens_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :config_id (required, String) —

    The ID of the Amazon S3 Storage Lens configuration.

  • :account_id (required, String) —

    The account ID of the requester.

Returns:

See Also:



3106
3107
3108
3109
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3106

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

#get_storage_lens_configuration_tagging(params = {}) ⇒ Types::GetStorageLensConfigurationTaggingResult

Gets the tags of Amazon S3 Storage Lens configuration. For more information about S3 Storage Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens in the Amazon S3 User Guide.

To use this action, you must have permission to perform the s3:GetStorageLensConfigurationTagging action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the Amazon S3 User Guide.

Examples:

Request syntax with placeholder values


resp = client.get_storage_lens_configuration_tagging({
  config_id: "ConfigId", # required
  account_id: "AccountId", # required
})

Response structure


resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :config_id (required, String) —

    The ID of the Amazon S3 Storage Lens configuration.

  • :account_id (required, String) —

    The account ID of the requester.

Returns:

See Also:



3155
3156
3157
3158
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3155

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

#list_access_points(params = {}) ⇒ Types::ListAccessPointsResult

Returns a list of the access points currently associated with the specified bucket. You can retrieve up to 1000 access points per call. If the specified bucket has more than 1,000 access points (or the number specified in maxResults, whichever is less), the response will include a continuation token that you can use to list the additional access points.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to ListAccessPoints:

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_access_points({
  account_id: "AccountId", # required
  bucket: "BucketName",
  next_token: "NonEmptyMaxLength1024String",
  max_results: 1,
})

Response structure


resp.access_point_list #=> Array
resp.access_point_list[0].name #=> String
resp.access_point_list[0].network_origin #=> String, one of "Internet", "VPC"
resp.access_point_list[0].vpc_configuration.vpc_id #=> String
resp.access_point_list[0].bucket #=> String
resp.access_point_list[0].access_point_arn #=> String
resp.access_point_list[0].alias #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for owner of the bucket whose access points you want to list.

  • :bucket (String) —

    The name of the bucket whose associated access points you want to list.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

  • :next_token (String) —

    A continuation token. If a previous call to ListAccessPoints returned a continuation token in the NextToken field, then providing that value here causes Amazon S3 to retrieve the next page of results.

  • :max_results (Integer) —

    The maximum number of access points that you want to include in the list. If the specified bucket has more than this number of access points, then the response will include a continuation token in the NextToken field that you can use to retrieve the next page of access points.

Returns:

See Also:



3256
3257
3258
3259
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3256

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

#list_access_points_for_object_lambda(params = {}) ⇒ Types::ListAccessPointsForObjectLambdaResult

Returns a list of the access points associated with the Object Lambda Access Point. You can retrieve up to 1000 access points per call. If there are more than 1,000 access points (or the number specified in maxResults, whichever is less), the response will include a continuation token that you can use to list the additional access points.

The following actions are related to ListAccessPointsForObjectLambda:

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_access_points_for_object_lambda({
  account_id: "AccountId", # required
  next_token: "NonEmptyMaxLength1024String",
  max_results: 1,
})

Response structure


resp.object_lambda_access_point_list #=> Array
resp.object_lambda_access_point_list[0].name #=> String
resp.object_lambda_access_point_list[0].object_lambda_access_point_arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :next_token (String) —

    If the list has more access points than can be returned in one call to this API, this field contains a continuation token that you can provide in subsequent calls to this API to retrieve additional access points.

  • :max_results (Integer) —

    The maximum number of access points that you want to include in the list. If there are more than this number of access points, then the response will include a continuation token in the NextToken field that you can use to retrieve the next page of access points.

Returns:

See Also:



3325
3326
3327
3328
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3325

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

#list_jobs(params = {}) ⇒ Types::ListJobsResult

Lists current S3 Batch Operations jobs and jobs that have ended within the last 30 days for the Amazon Web Services account making the request. For more information, see S3 Batch Operations in the Amazon S3 User Guide.

Related actions include:

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_jobs({
  account_id: "AccountId", # required
  job_statuses: ["Active"], # accepts Active, Cancelled, Cancelling, Complete, Completing, Failed, Failing, New, Paused, Pausing, Preparing, Ready, Suspended
  next_token: "StringForNextToken",
  max_results: 1,
})

Response structure


resp.next_token #=> String
resp.jobs #=> Array
resp.jobs[0].job_id #=> String
resp.jobs[0].description #=> String
resp.jobs[0].operation #=> String, one of "LambdaInvoke", "S3PutObjectCopy", "S3PutObjectAcl", "S3PutObjectTagging", "S3DeleteObjectTagging", "S3InitiateRestoreObject", "S3PutObjectLegalHold", "S3PutObjectRetention"
resp.jobs[0].priority #=> Integer
resp.jobs[0].status #=> String, one of "Active", "Cancelled", "Cancelling", "Complete", "Completing", "Failed", "Failing", "New", "Paused", "Pausing", "Preparing", "Ready", "Suspended"
resp.jobs[0].creation_time #=> Time
resp.jobs[0].termination_date #=> Time
resp.jobs[0].progress_summary.total_number_of_tasks #=> Integer
resp.jobs[0].progress_summary.number_of_tasks_succeeded #=> Integer
resp.jobs[0].progress_summary.number_of_tasks_failed #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID associated with the S3 Batch Operations job.

  • :job_statuses (Array<String>) —

    The List Jobs request returns jobs that match the statuses listed in this element.

  • :next_token (String) —

    A pagination token to request the next page of results. Use the token that Amazon S3 returned in the NextToken element of the ListJobsResult from the previous List Jobs request.

  • :max_results (Integer) —

    The maximum number of jobs that Amazon S3 will include in the List Jobs response. If there are more jobs than this number, the response will include a pagination token in the NextToken field to enable you to retrieve the next page of results.

Returns:

See Also:



3409
3410
3411
3412
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3409

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

#list_multi_region_access_points(params = {}) ⇒ Types::ListMultiRegionAccessPointsResult

Returns a list of the Multi-Region Access Points currently associated with the specified Amazon Web Services account. Each call can return up to 100 Multi-Region Access Points, the maximum number of Multi-Region Access Points that can be associated with a single account.

This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around managing Multi-Region Access Points, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

The following actions are related to ListMultiRegionAccessPoint:

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_multi_region_access_points({
  account_id: "AccountId", # required
  next_token: "NonEmptyMaxLength1024String",
  max_results: 1,
})

Response structure


resp.access_points #=> Array
resp.access_points[0].name #=> String
resp.access_points[0].alias #=> String
resp.access_points[0].created_at #=> Time
resp.access_points[0].public_access_block.block_public_acls #=> Boolean
resp.access_points[0].public_access_block.ignore_public_acls #=> Boolean
resp.access_points[0].public_access_block.block_public_policy #=> Boolean
resp.access_points[0].public_access_block.restrict_public_buckets #=> Boolean
resp.access_points[0].status #=> String, one of "READY", "INCONSISTENT_ACROSS_REGIONS", "CREATING", "PARTIALLY_CREATED", "PARTIALLY_DELETED", "DELETING"
resp.access_points[0].regions #=> Array
resp.access_points[0].regions[0].bucket #=> String
resp.access_points[0].regions[0].region #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point.

  • :next_token (String) —

    Not currently used. Do not use this parameter.

  • :max_results (Integer) —

    Not currently used. Do not use this parameter.

Returns:

See Also:



3488
3489
3490
3491
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3488

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

#list_regional_buckets(params = {}) ⇒ Types::ListRegionalBucketsResult

Returns a list of all Outposts buckets in an Outpost that are owned by the authenticated sender of the request. For more information, see Using Amazon S3 on Outposts in the Amazon S3 User Guide.

For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and x-amz-outpost-id in your request, see the Examples section.

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_regional_buckets({
  account_id: "AccountId", # required
  next_token: "NonEmptyMaxLength1024String",
  max_results: 1,
  outpost_id: "NonEmptyMaxLength64String",
})

Response structure


resp.regional_bucket_list #=> Array
resp.regional_bucket_list[0].bucket #=> String
resp.regional_bucket_list[0].bucket_arn #=> String
resp.regional_bucket_list[0].public_access_block_enabled #=> Boolean
resp.regional_bucket_list[0].creation_date #=> Time
resp.regional_bucket_list[0].outpost_id #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :next_token (String)
  • :max_results (Integer)
  • :outpost_id (String) —

    The ID of the Outposts.

    This is required by Amazon S3 on Outposts buckets.

Returns:

See Also:



3550
3551
3552
3553
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3550

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

#list_storage_lens_configurations(params = {}) ⇒ Types::ListStorageLensConfigurationsResult

Gets a list of Amazon S3 Storage Lens configurations. For more information about S3 Storage Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens in the Amazon S3 User Guide.

To use this action, you must have permission to perform the s3:ListStorageLensConfigurations action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the Amazon S3 User Guide.

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_storage_lens_configurations({
  account_id: "AccountId", # required
  next_token: "ContinuationToken",
})

Response structure


resp.next_token #=> String
resp.storage_lens_configuration_list #=> Array
resp.storage_lens_configuration_list[0].id #=> String
resp.storage_lens_configuration_list[0].storage_lens_arn #=> String
resp.storage_lens_configuration_list[0].home_region #=> String
resp.storage_lens_configuration_list[0].is_enabled #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID of the requester.

  • :next_token (String) —

    A pagination token to request the next page of results.

Returns:

See Also:



3605
3606
3607
3608
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3605

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

#put_access_point_configuration_for_object_lambda(params = {}) ⇒ Struct

Replaces configuration for an Object Lambda Access Point.

The following actions are related to PutAccessPointConfigurationForObjectLambda:

^

Examples:

Request syntax with placeholder values


resp = client.put_access_point_configuration_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
  configuration: { # required
    supporting_access_point: "ObjectLambdaSupportingAccessPointArn", # required
    cloud_watch_metrics_enabled: false,
    allowed_features: ["GetObject-Range"], # accepts GetObject-Range, GetObject-PartNumber
    transformation_configurations: [ # required
      {
        actions: ["GetObject"], # required, accepts GetObject
        content_transformation: { # required
          aws_lambda: {
            function_arn: "FunctionArnString", # required
            function_payload: "AwsLambdaTransformationPayload",
          },
        },
      },
    ],
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the Object Lambda Access Point.

  • :configuration (required, Types::ObjectLambdaConfiguration) —

    Object Lambda Access Point configuration document.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3662
3663
3664
3665
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3662

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

#put_access_point_policy(params = {}) ⇒ Struct

Associates an access policy with the specified access point. Each access point can have only one policy, so a request made to this API replaces any existing policy associated with the specified access point.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to PutAccessPointPolicy:

Examples:

Request syntax with placeholder values


resp = client.put_access_point_policy({
  account_id: "AccountId", # required
  name: "AccessPointName", # required
  policy: "Policy", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for owner of the bucket associated with the specified access point.

  • :name (required, String) —

    The name of the access point that you want to associate with the specified policy.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the access point accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/accesspoint/<my-accesspoint-name>. For example, to access the access point reports-ap through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/accesspoint/reports-ap. The value must be URL encoded.

  • :policy (required, String) —

    The policy that you want to apply to the specified access point. For more information about access point policies, see Managing data access with Amazon S3 access points in the Amazon S3 User Guide.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3738
3739
3740
3741
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3738

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

#put_access_point_policy_for_object_lambda(params = {}) ⇒ Struct

Creates or replaces resource policy for an Object Lambda Access Point. For an example policy, see Creating Object Lambda Access Points in the Amazon S3 User Guide.

The following actions are related to PutAccessPointPolicyForObjectLambda:

Examples:

Request syntax with placeholder values


resp = client.put_access_point_policy_for_object_lambda({
  account_id: "AccountId", # required
  name: "ObjectLambdaAccessPointName", # required
  policy: "ObjectLambdaPolicy", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The account ID for the account that owns the specified Object Lambda Access Point.

  • :name (required, String) —

    The name of the Object Lambda Access Point.

  • :policy (required, String) —

    Object Lambda Access Point resource policy document.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3784
3785
3786
3787
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3784

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

#put_bucket_lifecycle_configuration(params = {}) ⇒ Struct

This action puts a lifecycle configuration to an Amazon S3 on Outposts bucket. To put a lifecycle configuration to an S3 bucket, see PutBucketLifecycleConfiguration in the Amazon S3 API Reference.

Creates a new lifecycle configuration for the S3 on Outposts bucket or replaces an existing lifecycle configuration. Outposts buckets only support lifecycle configurations that delete/expire objects after a certain period of time and abort incomplete multipart uploads.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to PutBucketLifecycleConfiguration:

Examples:

Request syntax with placeholder values


resp = client.put_bucket_lifecycle_configuration({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
  lifecycle_configuration: {
    rules: [
      {
        expiration: {
          date: Time.now,
          days: 1,
          expired_object_delete_marker: false,
        },
        id: "ID",
        filter: {
          prefix: "Prefix",
          tag: {
            key: "TagKeyString", # required
            value: "TagValueString", # required
          },
          and: {
            prefix: "Prefix",
            tags: [
              {
                key: "TagKeyString", # required
                value: "TagValueString", # required
              },
            ],
          },
        },
        status: "Enabled", # required, accepts Enabled, Disabled
        transitions: [
          {
            date: Time.now,
            days: 1,
            storage_class: "GLACIER", # accepts GLACIER, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, DEEP_ARCHIVE
          },
        ],
        noncurrent_version_transitions: [
          {
            noncurrent_days: 1,
            storage_class: "GLACIER", # accepts GLACIER, STANDARD_IA, ONEZONE_IA, INTELLIGENT_TIERING, DEEP_ARCHIVE
          },
        ],
        noncurrent_version_expiration: {
          noncurrent_days: 1,
        },
        abort_incomplete_multipart_upload: {
          days_after_initiation: 1,
        },
      },
    ],
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :bucket (required, String) —

    The name of the bucket for which to set the configuration.

  • :lifecycle_configuration (Types::LifecycleConfiguration) —

    Container for lifecycle rules. You can add as many as 1,000 rules.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3894
3895
3896
3897
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3894

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

#put_bucket_policy(params = {}) ⇒ Struct

This action puts a bucket policy to an Amazon S3 on Outposts bucket. To put a policy on an S3 bucket, see PutBucketPolicy in the Amazon S3 API Reference.

Applies an Amazon S3 bucket policy to an Outposts bucket. For more information, see Using Amazon S3 on Outposts in the Amazon S3 User Guide.

If you are using an identity other than the root user of the Amazon Web Services account that owns the Outposts bucket, the calling identity must have the PutBucketPolicy permissions on the specified Outposts bucket and belong to the bucket owner's account in order to use this action.

If you don't have PutBucketPolicy permissions, Amazon S3 returns a 403 Access Denied error. If you have the correct permissions, but you're not using an identity that belongs to the bucket owner's account, Amazon S3 returns a 405 Method Not Allowed error.

As a security precaution, the root user of the Amazon Web Services account that owns a bucket can always use this action, even if the policy explicitly denies the root user the ability to perform this action.

For more information about bucket policies, see Using Bucket Policies and User Policies.

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to PutBucketPolicy:

Examples:

Request syntax with placeholder values


resp = client.put_bucket_policy({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
  confirm_remove_self_bucket_access: false,
  policy: "Policy", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :bucket (required, String) —

    Specifies the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

  • :confirm_remove_self_bucket_access (Boolean) —

    Set this parameter to true to confirm that you want to remove your permissions to change this bucket policy in the future.

    This is not supported by Amazon S3 on Outposts buckets.

  • :policy (required, String) —

    The bucket policy as a JSON document.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3996
3997
3998
3999
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 3996

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

#put_bucket_tagging(params = {}) ⇒ Struct

This action puts tags on an Amazon S3 on Outposts bucket. To put tags on an S3 bucket, see PutBucketTagging in the Amazon S3 API Reference.

Sets the tags for an S3 on Outposts bucket. For more information, see Using Amazon S3 on Outposts in the Amazon S3 User Guide.

Use tags to organize your Amazon Web Services bill to reflect your own cost structure. To do this, sign up to get your Amazon Web Services account bill with tag key values included. Then, to see the cost of combined resources, organize your billing information according to resources with the same tag key values. For example, you can tag several resources with a specific application name, and then organize your billing information to see the total cost of that application across several services. For more information, see Cost allocation and tagging.

Within a bucket, if you add a tag that has the same key as an existing tag, the new value overwrites the old value. For more information, see Using cost allocation in Amazon S3 bucket tags.

To use this action, you must have permissions to perform the s3-outposts:PutBucketTagging action. The Outposts bucket owner has this permission by default and can grant this permission to others. For more information about permissions, see Permissions Related to Bucket Subresource Operations and Managing access permissions to your Amazon S3 resources.

PutBucketTagging has the following special errors:

  • Error code: InvalidTagError

    ^

  • Error code: MalformedXMLError

    • Description: The XML provided does not match the schema.

    ^

  • Error code: OperationAbortedError

    • Description: A conflicting conditional action is currently in progress against this resource. Try again.

    ^

  • Error code: InternalError

    • Description: The service was unable to apply the provided tag to the bucket.

    ^

All Amazon S3 on Outposts REST API requests for this action require an additional parameter of x-amz-outpost-id to be passed with the request and an S3 on Outposts endpoint hostname prefix instead of s3-control. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the x-amz-outpost-id derived using the access point ARN, see the Examples section.

The following actions are related to PutBucketTagging:

Examples:

Request syntax with placeholder values


resp = client.put_bucket_tagging({
  account_id: "AccountId", # required
  bucket: "BucketName", # required
  tagging: { # required
    tag_set: [ # required
      {
        key: "TagKeyString", # required
        value: "TagValueString", # required
      },
    ],
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID of the Outposts bucket.

  • :bucket (required, String) —

    The Amazon Resource Name (ARN) of the bucket.

    For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.

    For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format arn:aws:s3-outposts:<Region>:<account-id>:outpost/<outpost-id>/bucket/<my-bucket-name>. For example, to access the bucket reports through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports. The value must be URL encoded.

  • :tagging (required, Types::Tagging)

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4135
4136
4137
4138
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4135

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

#put_job_tagging(params = {}) ⇒ Struct

Sets the supplied tag-set on an S3 Batch Operations job.

A tag is a key-value pair. You can associate S3 Batch Operations tags with any job by sending a PUT request against the tagging subresource that is associated with the job. To modify the existing tag set, you can either replace the existing tag set entirely, or make changes within the existing tag set by retrieving the existing tag set using GetJobTagging, modify that tag set, and use this action to replace the tag set with the one you modified. For more information, see Controlling access and labeling jobs using tags in the Amazon S3 User Guide.

* If you send this request with an empty tag set, Amazon S3 deletes the existing tag set on the Batch Operations job. If you use this method, you are charged for a Tier 1 Request (PUT). For more information, see Amazon S3 pricing.

  • For deleting existing tags for your Batch Operations job, a DeleteJobTagging request is preferred because it achieves the same result without incurring charges.

  • A few things to consider about using tags:

    • Amazon S3 limits the maximum number of tags to 50 tags per job.

    • You can associate up to 50 tags with a job as long as they have unique tag keys.

    • A tag key can be up to 128 Unicode characters in length, and tag values can be up to 256 Unicode characters in length.

    • The key and values are case sensitive.

    • For tagging-related restrictions related to characters and encodings, see User-Defined Tag Restrictions in the Billing and Cost Management User Guide.

To use this action, you must have permission to perform the s3:PutJobTagging action.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.put_job_tagging({
  account_id: "AccountId", # required
  job_id: "JobId", # required
  tags: [ # required
    {
      key: "TagKeyString", # required
      value: "TagValueString", # required
    },
  ],
})

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID associated with the S3 Batch Operations job.

  • :job_id (required, String) —

    The ID for the S3 Batch Operations job whose tags you want to replace.

  • :tags (required, Array<Types::S3Tag>) —

    The set of tags to associate with the S3 Batch Operations job.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4232
4233
4234
4235
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4232

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

#put_multi_region_access_point_policy(params = {}) ⇒ Types::PutMultiRegionAccessPointPolicyResult

Associates an access control policy with the specified Multi-Region Access Point. Each Multi-Region Access Point can have only one policy, so a request made to this action replaces any existing policy that is associated with the specified Multi-Region Access Point.

This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around managing Multi-Region Access Points, see Managing Multi-Region Access Points in the Amazon S3 User Guide.

The following actions are related to PutMultiRegionAccessPointPolicy:

Examples:

Request syntax with placeholder values


resp = client.put_multi_region_access_point_policy({
  account_id: "AccountId", # required
  client_token: "MultiRegionAccessPointClientToken", # required
  details: { # required
    name: "MultiRegionAccessPointName", # required
    policy: "Policy", # required
  },
})

Response structure


resp.request_token_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID for the owner of the Multi-Region Access Point.

  • :client_token (required, String) —

    An idempotency token used to identify the request and guarantee that requests are unique.

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

  • :details (required, Types::PutMultiRegionAccessPointPolicyInput) —

    A container element containing the details of the policy for the Multi-Region Access Point.

Returns:

See Also:



4298
4299
4300
4301
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4298

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

#put_public_access_block(params = {}) ⇒ Struct

Creates or modifies the PublicAccessBlock configuration for an Amazon Web Services account. For more information, see Using Amazon S3 block public access.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.put_public_access_block({
  public_access_block_configuration: { # required
    block_public_acls: false,
    ignore_public_acls: false,
    block_public_policy: false,
    restrict_public_buckets: false,
  },
  account_id: "AccountId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :public_access_block_configuration (required, Types::PublicAccessBlockConfiguration) —

    The PublicAccessBlock configuration that you want to apply to the specified Amazon Web Services account.

  • :account_id (required, String) —

    The account ID for the Amazon Web Services account whose PublicAccessBlock configuration you want to set.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4345
4346
4347
4348
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4345

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

#put_storage_lens_configuration(params = {}) ⇒ Struct

Puts an Amazon S3 Storage Lens configuration. For more information about S3 Storage Lens, see Working with Amazon S3 Storage Lens in the Amazon S3 User Guide.

To use this action, you must have permission to perform the s3:PutStorageLensConfiguration action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the Amazon S3 User Guide.

Examples:

Request syntax with placeholder values


resp = client.put_storage_lens_configuration({
  config_id: "ConfigId", # required
  account_id: "AccountId", # required
  storage_lens_configuration: { # required
    id: "ConfigId", # required
    account_level: { # required
      activity_metrics: {
        is_enabled: false,
      },
      bucket_level: { # required
        activity_metrics: {
          is_enabled: false,
        },
        prefix_level: {
          storage_metrics: { # required
            is_enabled: false,
            selection_criteria: {
              delimiter: "StorageLensPrefixLevelDelimiter",
              max_depth: 1,
              min_storage_bytes_percentage: 1.0,
            },
          },
        },
      },
    },
    include: {
      buckets: ["S3BucketArnString"],
      regions: ["S3AWSRegion"],
    },
    exclude: {
      buckets: ["S3BucketArnString"],
      regions: ["S3AWSRegion"],
    },
    data_export: {
      s3_bucket_destination: { # required
        format: "CSV", # required, accepts CSV, Parquet
        output_schema_version: "V_1", # required, accepts V_1
        account_id: "AccountId", # required
        arn: "S3BucketArnString", # required
        prefix: "Prefix",
        encryption: {
          sses3: {
          },
          ssekms: {
            key_id: "SSEKMSKeyId", # required
          },
        },
      },
    },
    is_enabled: false, # required
    aws_org: {
      arn: "AwsOrgArn", # required
    },
    storage_lens_arn: "StorageLensArn",
  },
  tags: [
    {
      key: "TagKeyString", # required
      value: "TagValueString", # required
    },
  ],
})

Parameters:

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

    ({})

Options Hash (params):

  • :config_id (required, String) —

    The ID of the S3 Storage Lens configuration.

  • :account_id (required, String) —

    The account ID of the requester.

  • :storage_lens_configuration (required, Types::StorageLensConfiguration) —

    The S3 Storage Lens configuration.

  • :tags (Array<Types::StorageLensTag>) —

    The tag set of the S3 Storage Lens configuration.

    You can set up to a maximum of 50 tags.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4453
4454
4455
4456
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4453

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

#put_storage_lens_configuration_tagging(params = {}) ⇒ Struct

Put or replace tags on an existing Amazon S3 Storage Lens configuration. For more information about S3 Storage Lens, see Assessing your storage activity and usage with Amazon S3 Storage Lens in the Amazon S3 User Guide.

To use this action, you must have permission to perform the s3:PutStorageLensConfigurationTagging action. For more information, see Setting permissions to use Amazon S3 Storage Lens in the Amazon S3 User Guide.

Examples:

Request syntax with placeholder values


resp = client.put_storage_lens_configuration_tagging({
  config_id: "ConfigId", # required
  account_id: "AccountId", # required
  tags: [ # required
    {
      key: "TagKeyString", # required
      value: "TagValueString", # required
    },
  ],
})

Parameters:

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

    ({})

Options Hash (params):

  • :config_id (required, String) —

    The ID of the S3 Storage Lens configuration.

  • :account_id (required, String) —

    The account ID of the requester.

  • :tags (required, Array<Types::StorageLensTag>) —

    The tag set of the S3 Storage Lens configuration.

    You can set up to a maximum of 50 tags.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



4507
4508
4509
4510
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4507

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

#update_job_priority(params = {}) ⇒ Types::UpdateJobPriorityResult

Updates an existing S3 Batch Operations job's priority. For more information, see S3 Batch Operations in the Amazon S3 User Guide.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.update_job_priority({
  account_id: "AccountId", # required
  job_id: "JobId", # required
  priority: 1, # required
})

Response structure


resp.job_id #=> String
resp.priority #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID associated with the S3 Batch Operations job.

  • :job_id (required, String) —

    The ID for the job whose priority you want to update.

  • :priority (required, Integer) —

    The priority you want to assign to this job.

Returns:

See Also:



4568
4569
4570
4571
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4568

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

#update_job_status(params = {}) ⇒ Types::UpdateJobStatusResult

Updates the status for the specified job. Use this action to confirm that you want to run a job or to cancel an existing job. For more information, see S3 Batch Operations in the Amazon S3 User Guide.

Related actions include:

Examples:

Request syntax with placeholder values


resp = client.update_job_status({
  account_id: "AccountId", # required
  job_id: "JobId", # required
  requested_job_status: "Cancelled", # required, accepts Cancelled, Ready
  status_update_reason: "JobStatusUpdateReason",
})

Response structure


resp.job_id #=> String
resp.status #=> String, one of "Active", "Cancelled", "Cancelling", "Complete", "Completing", "Failed", "Failing", "New", "Paused", "Pausing", "Preparing", "Ready", "Suspended"
resp.status_update_reason #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :account_id (required, String) —

    The Amazon Web Services account ID associated with the S3 Batch Operations job.

  • :job_id (required, String) —

    The ID of the job whose status you want to update.

  • :requested_job_status (required, String) —

    The status that you want to move the specified job to.

  • :status_update_reason (String) —

    A description of the reason why you want to change the specified job's status. This field can be any string up to the maximum length.

Returns:

See Also:



4637
4638
4639
4640
 
# File 'gems/aws-sdk-s3control/lib/aws-sdk-s3control/client.rb', line 4637

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