/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include // TODO: temporary fix for naming conflicts on Windows. #ifdef _WIN32 #ifdef GetObject #undef GetObject #endif #endif namespace Aws { namespace S3 { namespace SSEHeaders { static const char SERVER_SIDE_ENCRYPTION[] = "x-amz-server-side-encryption"; static const char SERVER_SIDE_ENCRYPTION_AWS_KMS_KEY_ID[] = "x-amz-server-side-encryption-aws-kms-key-id"; static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_ALGORITHM[] = "x-amz-server-side-encryption-customer-algorithm"; static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY[] = "x-amz-server-side-encryption-customer-key"; static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5[] = "x-amz-server-side-encryption-customer-key-MD5"; } // SS3Headers //max expiration for presigned urls in s3 is 7 days. static const unsigned MAX_EXPIRATION_SECONDS = 7 * 24 * 60 * 60; /** *

*/ class AWS_S3_API S3Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3Client(const Aws::S3::S3ClientConfiguration& clientConfiguration = Aws::S3::S3ClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::S3::S3ClientConfiguration& clientConfiguration = Aws::S3::S3ClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ S3Client(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::S3::S3ClientConfiguration& clientConfiguration = Aws::S3::S3ClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3Client(const Aws::Client::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads, bool useVirtualAddressing, Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption = Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads, bool useVirtualAddressing, Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption = Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ S3Client(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signPayloads, bool useVirtualAddressing, Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION USEast1RegionalEndPointOption = Aws::S3::US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET); /* End of legacy constructors due deprecation */ virtual ~S3Client(); /** *

This action aborts a multipart upload. After a multipart upload is aborted, * no additional parts can be uploaded using that upload ID. The storage consumed * by any previously uploaded parts will be freed. However, if any part uploads are * currently in progress, those part uploads might or might not succeed. As a * result, it might be necessary to abort a given multipart upload multiple times * in order to completely free all storage consumed by all parts.

To verify * that all parts have been removed, so you don't get charged for the part storage, * you should call the ListParts * action and ensure that the parts list is empty.

For information about * permissions required to use the multipart upload, see Multipart * Upload and Permissions.

The following operations are related to * AbortMultipartUpload:

See Also:

AWS * API Reference

*/ virtual Model::AbortMultipartUploadOutcome AbortMultipartUpload(const Model::AbortMultipartUploadRequest& request) const; /** * A Callable wrapper for AbortMultipartUpload that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AbortMultipartUploadOutcomeCallable AbortMultipartUploadCallable(const AbortMultipartUploadRequestT& request) const { return SubmitCallable(&S3Client::AbortMultipartUpload, request); } /** * An Async wrapper for AbortMultipartUpload that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AbortMultipartUploadAsync(const AbortMultipartUploadRequestT& request, const AbortMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::AbortMultipartUpload, request, handler, context); } /** *

Completes a multipart upload by assembling previously uploaded parts.

*

You first initiate the multipart upload and then upload all parts using the * UploadPart * operation. After successfully uploading all relevant parts of an upload, you * call this action to complete the upload. Upon receiving this request, Amazon S3 * concatenates all the parts in ascending order by part number to create a new * object. In the Complete Multipart Upload request, you must provide the parts * list. You must ensure that the parts list is complete. This action concatenates * the parts that you provide in the list. For each part in the list, you must * provide the part number and the ETag value, returned after that * part was uploaded.

Processing of a Complete Multipart Upload request * could take several minutes to complete. After Amazon S3 begins processing the * request, it sends an HTTP response header that specifies a 200 OK response. * While processing is in progress, Amazon S3 periodically sends white space * characters to keep the connection from timing out. Because a request could fail * after the initial 200 OK response has been sent, it is important that you check * the response body to determine whether the request succeeded.

Note that * if CompleteMultipartUpload fails, applications should be prepared * to retry the failed requests. For more information, see Amazon * S3 Error Best Practices.

You cannot use * Content-Type: application/x-www-form-urlencoded with Complete * Multipart Upload requests. Also, if you do not provide a * Content-Type header, CompleteMultipartUpload returns a * 200 OK response.

For more information about multipart * uploads, see Uploading * Objects Using Multipart Upload.

For information about permissions * required to use the multipart upload API, see Multipart * Upload and Permissions.

CompleteMultipartUpload has the * following special errors:

  • Error code: * EntityTooSmall

    • Description: Your proposed upload * is smaller than the minimum allowed object size. Each part must be at least 5 MB * in size, except the last part.

    • 400 Bad Request

    *

  • Error code: InvalidPart

    • *

      Description: One or more of the specified parts could not be found. The part * might not have been uploaded, or the specified entity tag might not have matched * the part's entity tag.

    • 400 Bad Request

    • *

  • Error code: InvalidPartOrder

    • Description: * The list of parts was not in ascending order. The parts list must be specified * in order by part number.

    • 400 Bad Request

    • *

  • Error code: NoSuchUpload

    • Description: The * specified multipart upload does not exist. The upload ID might be invalid, or * the multipart upload might have been aborted or completed.

    • 404 * Not Found

The following operations are related to * CompleteMultipartUpload:

See Also:

AWS * API Reference

*/ virtual Model::CompleteMultipartUploadOutcome CompleteMultipartUpload(const Model::CompleteMultipartUploadRequest& request) const; /** * A Callable wrapper for CompleteMultipartUpload that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CompleteMultipartUploadOutcomeCallable CompleteMultipartUploadCallable(const CompleteMultipartUploadRequestT& request) const { return SubmitCallable(&S3Client::CompleteMultipartUpload, request); } /** * An Async wrapper for CompleteMultipartUpload that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CompleteMultipartUploadAsync(const CompleteMultipartUploadRequestT& request, const CompleteMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::CompleteMultipartUpload, request, handler, context); } /** *

Creates a copy of an object that is already stored in Amazon S3.

*

You can store individual objects of up to 5 TB in Amazon S3. You create a * copy of your object up to 5 GB in size in a single atomic action using this API. * However, to copy an object greater than 5 GB, you must use the multipart upload * Upload Part - Copy (UploadPartCopy) API. For more information, see Copy * Object Using the REST Multipart Upload API.

All copy requests * must be authenticated. Additionally, you must have read access to the * source object and write access to the destination bucket. For more * information, see REST * Authentication. Both the Region that you want to copy the object from and * the Region that you want to copy the object to must be enabled for your * account.

A copy request might return an error when Amazon S3 receives the * copy request or while Amazon S3 is copying the files. If the error occurs before * the copy action starts, you receive a standard Amazon S3 error. If the error * occurs during the copy operation, the error response is embedded in the * 200 OK response. This means that a 200 OK response can * contain either a success or an error. Design your application to parse the * contents of the response and handle it appropriately.

If the copy is * successful, you receive a response with information about the copied object.

*

If the request is an HTTP 1.1 request, the response is chunk encoded. * If it were not, it would not contain the content-length, and you would need to * read the entire body.

The copy request charge is based on the * storage class and Region that you specify for the destination object. For * pricing information, see Amazon S3 * pricing.

Amazon S3 transfer acceleration does not support * cross-Region copies. If you request a cross-Region copy using a transfer * acceleration endpoint, you get a 400 Bad Request error. For more * information, see Transfer * Acceleration.

Metadata

When copying an * object, you can preserve all metadata (default) or specify new metadata. * However, the ACL is not preserved and is set to private for the user making the * request. To override the default ACL setting, specify a new ACL when generating * a copy request. For more information, see Using * ACLs.

To specify whether you want the object metadata copied from * the source object or replaced with metadata provided in the request, you can * optionally add the x-amz-metadata-directive header. When you grant * permissions, you can use the s3:x-amz-metadata-directive condition * key to enforce certain metadata behavior when objects are uploaded. For more * information, see Specifying * Conditions in a Policy in the Amazon S3 User Guide. For a complete * list of Amazon S3-specific condition keys, see Actions, * Resources, and Condition Keys for Amazon S3.

x-amz-copy-source-if * Headers

To only copy an object under certain conditions, such as * whether the Etag matches or whether the object was modified before * or after a specified date, use the following request parameters:

  • *

    x-amz-copy-source-if-match

  • * x-amz-copy-source-if-none-match

  • * x-amz-copy-source-if-unmodified-since

  • * x-amz-copy-source-if-modified-since

If both * the x-amz-copy-source-if-match and * x-amz-copy-source-if-unmodified-since headers are present in the * request and evaluate as follows, Amazon S3 returns 200 OK and * copies the data:

  • x-amz-copy-source-if-match * condition evaluates to true

  • * x-amz-copy-source-if-unmodified-since condition evaluates to * false

If both the * x-amz-copy-source-if-none-match and * x-amz-copy-source-if-modified-since headers are present in the * request and evaluate as follows, Amazon S3 returns the 412 Precondition * Failed response code:

  • * x-amz-copy-source-if-none-match condition evaluates to false

    *

  • x-amz-copy-source-if-modified-since condition * evaluates to true

All headers with the * x-amz- prefix, including x-amz-copy-source, must be * signed.

Server-side encryption

When you perform a * CopyObject operation, you can optionally use the appropriate encryption-related * headers to encrypt the object using server-side encryption with Amazon Web * Services managed encryption keys (SSE-S3 or SSE-KMS) or a customer-provided * encryption key. With server-side encryption, Amazon S3 encrypts your data as it * writes it to disks in its data centers and decrypts the data when you access it. * For more information about server-side encryption, see Using * Server-Side Encryption.

If a target object uses SSE-KMS, you can * enable an S3 Bucket Key for the object. For more information, see Amazon S3 * Bucket Keys in the Amazon S3 User Guide.

Access Control * List (ACL)-Specific Request Headers

When copying an object, you can * optionally use headers to grant ACL-based permissions. By default, all objects * are private. Only the owner has full access control. When adding a new object, * you can grant permissions to individual Amazon Web Services accounts or to * predefined groups defined by Amazon S3. These permissions are then added to the * ACL on the object. For more information, see Access * Control List (ACL) Overview and Managing * ACLs Using the REST API.

If the bucket that you're copying objects * to uses the bucket owner enforced setting for S3 Object Ownership, ACLs are * disabled and no longer affect permissions. Buckets that use this setting only * accept PUT requests that don't specify an ACL or PUT requests that specify * bucket owner full control ACLs, such as the * bucket-owner-full-control canned ACL or an equivalent form of this * ACL expressed in the XML format.

For more information, see * Controlling ownership of objects and disabling ACLs in the Amazon S3 User * Guide.

If your bucket uses the bucket owner enforced setting * for Object Ownership, all objects written to the bucket by any account will be * owned by the bucket owner.

Checksums

When copying * an object, if it has a checksum, that checksum will be copied to the new object * by default. When you copy the object over, you may optionally specify a * different checksum algorithm to use with the * x-amz-checksum-algorithm header.

Storage Class * Options

You can use the CopyObject action to change the * storage class of an object that is already stored in Amazon S3 using the * StorageClass parameter. For more information, see Storage * Classes in the Amazon S3 User Guide.

Versioning

*

By default, x-amz-copy-source identifies the current version of * an object to copy. If the current version is a delete marker, Amazon S3 behaves * as if the object was deleted. To copy a different version, use the * versionId subresource.

If you enable versioning on the * target bucket, Amazon S3 generates a unique version ID for the object being * copied. This version ID is different from the version ID of the source object. * Amazon S3 returns the version ID of the copied object in the * x-amz-version-id response header in the response.

If you do * not enable versioning or suspend it on the target bucket, the version ID that * Amazon S3 generates is always null.

If the source object's storage class * is GLACIER, you must restore a copy of this object before you can use it as a * source object for the copy operation. For more information, see RestoreObject.

*

The following operations are related to CopyObject:

For more information, see Copying * Objects.

See Also:

AWS API * Reference

*/ virtual Model::CopyObjectOutcome CopyObject(const Model::CopyObjectRequest& request) const; /** * A Callable wrapper for CopyObject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyObjectOutcomeCallable CopyObjectCallable(const CopyObjectRequestT& request) const { return SubmitCallable(&S3Client::CopyObject, request); } /** * An Async wrapper for CopyObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyObjectAsync(const CopyObjectRequestT& request, const CopyObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::CopyObject, request, handler, context); } /** *

Creates a new S3 bucket. To create a bucket, you must register with Amazon S3 * and have a valid Amazon Web Services Access Key ID to authenticate requests. * Anonymous requests are never allowed to create buckets. By creating the bucket, * you become the bucket owner.

Not every string is an acceptable bucket * name. For information about bucket naming restrictions, see Bucket * naming rules.

If you want to create an Amazon S3 on Outposts bucket, * see Create * Bucket.

By default, the bucket is created in the US East (N. * Virginia) Region. You can optionally specify a Region in the request body. You * might choose a Region to optimize latency, minimize costs, or address regulatory * requirements. For example, if you reside in Europe, you will probably find it * advantageous to create buckets in the Europe (Ireland) Region. For more * information, see Accessing * a bucket.

If you send your create bucket request to the * s3.amazonaws.com endpoint, the request goes to the us-east-1 * Region. Accordingly, the signature calculations in Signature Version 4 must use * us-east-1 as the Region, even if the location constraint in the request * specifies another Region where the bucket is to be created. If you create a * bucket in a Region other than US East (N. Virginia), your application must be * able to handle 307 redirect. For more information, see Virtual * hosting of buckets.

Access control lists (ACLs)

*

When creating a bucket using this operation, you can optionally configure the * bucket ACL to specify the accounts or groups that should be granted specific * permissions on the bucket.

If your CreateBucket request sets * bucket owner enforced for S3 Object Ownership and specifies a bucket ACL that * provides access to an external Amazon Web Services account, your request fails * with a 400 error and returns the * InvalidBucketAclWithObjectOwnership error code. For more * information, see Controlling * object ownership in the Amazon S3 User Guide.

*

There are two ways to grant the appropriate permissions using the request * headers.

  • Specify a canned ACL using the x-amz-acl * request header. Amazon S3 supports a set of predefined ACLs, known as canned * ACLs. Each canned ACL has a predefined set of grantees and permissions. For * more information, see Canned * ACL.

  • Specify access permissions explicitly using the * x-amz-grant-read, x-amz-grant-write, * x-amz-grant-read-acp, x-amz-grant-write-acp, and * x-amz-grant-full-control headers. These headers map to the set of * permissions Amazon S3 supports in an ACL. For more information, see Access * control list (ACL) overview.

    You specify each grantee as a type=value * pair, where the type is one of the following:

    • id * – if the value specified is the canonical user ID of an Amazon Web Services * account

    • uri – if you are granting permissions to * a predefined group

    • emailAddress – if the value * specified is the email address of an Amazon Web Services account

      *

      Using email addresses to specify a grantee is only supported in the following * Amazon Web Services Regions:

      • US East (N. Virginia)

        • *

      • US West (N. California)

      • US West (Oregon)

        • *

      • Asia Pacific (Singapore)

      • Asia Pacific (Sydney)

        *

      • Asia Pacific (Tokyo)

      • Europe (Ireland)

        • *

      • South America (São Paulo)

      For a list of all the * Amazon S3 supported Regions and endpoints, see Regions * and Endpoints in the Amazon Web Services General Reference.

      *

    For example, the following x-amz-grant-read header * grants the Amazon Web Services accounts identified by account IDs permissions to * read object data and its metadata:

    x-amz-grant-read: * id="11112222333", id="444455556666"

You can * use either a canned ACL or specify access permissions explicitly. You cannot do * both.

Permissions

In addition to * s3:CreateBucket, the following permissions are required when your * CreateBucket includes specific headers:

  • ACLs - If your * CreateBucket request specifies ACL permissions and the ACL is * public-read, public-read-write, authenticated-read, or if you specify access * permissions explicitly through any other ACL, both s3:CreateBucket * and s3:PutBucketAcl permissions are needed. If the ACL the * CreateBucket request is private or doesn't specify any ACLs, only * s3:CreateBucket permission is needed.

  • Object * Lock - If ObjectLockEnabledForBucket is set to true in your * CreateBucket request, * s3:PutBucketObjectLockConfiguration and * s3:PutBucketVersioning permissions are required.

  • * S3 Object Ownership - If your CreateBucket request includes the the * x-amz-object-ownership header, * s3:PutBucketOwnershipControls permission is required.

    • *

The following operations are related to CreateBucket:

*

See Also:

AWS API * Reference

*/ virtual Model::CreateBucketOutcome CreateBucket(const Model::CreateBucketRequest& request) const; /** * A Callable wrapper for CreateBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT& request) const { return SubmitCallable(&S3Client::CreateBucket, request); } /** * An Async wrapper for CreateBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBucketAsync(const CreateBucketRequestT& request, const CreateBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::CreateBucket, request, handler, context); } /** *

This action initiates a multipart upload and returns an upload ID. This * upload ID is used to associate all of the parts in the specific multipart * upload. You specify this upload ID in each of your subsequent upload part * requests (see UploadPart). * You also include this upload ID in the final request to either complete or abort * the multipart upload request.

For more information about multipart * uploads, see Multipart * Upload Overview.

If you have configured a lifecycle rule to abort * incomplete multipart uploads, the upload must complete within the number of days * specified in the bucket lifecycle configuration. Otherwise, the incomplete * multipart upload becomes eligible for an abort action and Amazon S3 aborts the * multipart upload. For more information, see Aborting * Incomplete Multipart Uploads Using a Bucket Lifecycle Policy.

For * information about the permissions required to use the multipart upload API, see * Multipart * Upload and Permissions.

For request signing, multipart upload is just * a series of regular requests. You initiate a multipart upload, send one or more * requests to upload parts, and then complete the multipart upload process. You * sign each request individually. There is nothing special about signing multipart * upload requests. For more information about signing, see Authenticating * Requests (Amazon Web Services Signature Version 4).

After you * initiate a multipart upload and upload one or more parts, to stop being charged * for storing the uploaded parts, you must either complete or abort the multipart * upload. Amazon S3 frees up the space used to store the parts and stop charging * you for storing them only after you either complete or abort a multipart upload. *

You can optionally request server-side encryption. For * server-side encryption, Amazon S3 encrypts your data as it writes it to disks in * its data centers and decrypts it when you access it. You can provide your own * encryption key, or use Amazon Web Services KMS keys or Amazon S3-managed * encryption keys. If you choose to provide your own encryption key, the request * headers you provide in UploadPart * and UploadPartCopy * requests must match the headers you used in the request to initiate the upload * by using CreateMultipartUpload.

To perform a multipart * upload with encryption using an Amazon Web Services KMS key, the requester must * have permission to the kms:Decrypt and * kms:GenerateDataKey* actions on the key. These permissions are * required because Amazon S3 must decrypt and read data from the encrypted file * parts before it completes the multipart upload. For more information, see Multipart * upload API and permissions in the Amazon S3 User Guide.

If * your Identity and Access Management (IAM) user or role is in the same Amazon Web * Services account as the KMS key, then you must have these permissions on the key * policy. If your IAM user or role belongs to a different account than the key, * then you must have the permissions on both the key policy and your IAM user or * role.

For more information, see Protecting * Data Using Server-Side Encryption.

Access Permissions
*

When copying an object, you can optionally specify the accounts or groups * that should be granted specific permissions on the new object. There are two * ways to grant the permissions using the request headers:

  • *

    Specify a canned ACL with the x-amz-acl request header. For more * information, see Canned * ACL.

  • Specify access permissions explicitly with the * x-amz-grant-read, x-amz-grant-read-acp, * x-amz-grant-write-acp, and x-amz-grant-full-control * headers. These parameters map to the set of permissions that Amazon S3 supports * in an ACL. For more information, see Access * Control List (ACL) Overview.

You can use either a canned * ACL or specify access permissions explicitly. You cannot do both.

*
Server-Side- Encryption-Specific Request Headers

You can * optionally tell Amazon S3 to encrypt data at rest using server-side encryption. * Server-side encryption is for data encryption at rest. Amazon S3 encrypts your * data as it writes it to disks in its data centers and decrypts it when you * access it. The option you use depends on whether you want to use Amazon Web * Services managed encryption keys or provide your own encryption key.

    *

  • Use encryption keys managed by Amazon S3 or customer managed key stored * in Amazon Web Services Key Management Service (Amazon Web Services KMS) – If you * want Amazon Web Services to manage the keys used to encrypt data, specify the * following headers in the request.

    • * x-amz-server-side-encryption

    • * x-amz-server-side-encryption-aws-kms-key-id

    • * x-amz-server-side-encryption-context

    If * you specify x-amz-server-side-encryption:aws:kms, but don't provide * x-amz-server-side-encryption-aws-kms-key-id, Amazon S3 uses the * Amazon Web Services managed key in Amazon Web Services KMS to protect the * data.

    All GET and PUT requests for an object * protected by Amazon Web Services KMS fail if you don't make them with SSL or by * using SigV4.

    For more information about server-side * encryption with KMS key (SSE-KMS), see Protecting * Data Using Server-Side Encryption with KMS keys.

  • Use * customer-provided encryption keys – If you want to manage your own encryption * keys, provide all the following headers in the request.

    • * x-amz-server-side-encryption-customer-algorithm

    • * x-amz-server-side-encryption-customer-key

    • * x-amz-server-side-encryption-customer-key-MD5

    *

    For more information about server-side encryption with KMS keys (SSE-KMS), * see Protecting * Data Using Server-Side Encryption with KMS keys.

*
Access-Control-List (ACL)-Specific Request Headers

You also can * use the following access control–related headers with this operation. By * default, all objects are private. Only the owner has full access control. When * adding a new object, you can grant permissions to individual Amazon Web Services * accounts or to predefined groups defined by Amazon S3. These permissions are * then added to the access control list (ACL) on the object. For more information, * see Using * ACLs. With this operation, you can grant access permissions using one of the * following two methods:

  • Specify a canned ACL * (x-amz-acl) — Amazon S3 supports a set of predefined ACLs, known as * canned ACLs. Each canned ACL has a predefined set of grantees and * permissions. For more information, see Canned * ACL.

  • Specify access permissions explicitly — To explicitly * grant access permissions to specific Amazon Web Services accounts or groups, use * the following headers. Each header maps to specific permissions that Amazon S3 * supports in an ACL. For more information, see Access * Control List (ACL) Overview. In the header, you specify a list of grantees * who get the specific permission. To grant permissions explicitly, use:

      *

    • x-amz-grant-read

    • * x-amz-grant-write

    • * x-amz-grant-read-acp

    • * x-amz-grant-write-acp

    • * x-amz-grant-full-control

    You specify each * grantee as a type=value pair, where the type is one of the following:

      *

    • id – if the value specified is the canonical user ID of an * Amazon Web Services account

    • uri – if you are * granting permissions to a predefined group

    • * emailAddress – if the value specified is the email address of an * Amazon Web Services account

      Using email addresses to specify a * grantee is only supported in the following Amazon Web Services Regions:

      *

      • US East (N. Virginia)

      • US West (N. California)

        *

      • US West (Oregon)

      • Asia Pacific (Singapore)

        *

      • Asia Pacific (Sydney)

      • Asia Pacific (Tokyo)

        *

      • Europe (Ireland)

      • South America (São Paulo)

        *

      For a list of all the Amazon S3 supported Regions and endpoints, * see Regions * and Endpoints in the Amazon Web Services General Reference.

      *

    For example, the following x-amz-grant-read header * grants the Amazon Web Services accounts identified by account IDs permissions to * read object data and its metadata:

    x-amz-grant-read: * id="11112222333", id="444455556666"

The * following operations are related to CreateMultipartUpload:

See Also:

AWS * API Reference

*/ virtual Model::CreateMultipartUploadOutcome CreateMultipartUpload(const Model::CreateMultipartUploadRequest& request) const; /** * A Callable wrapper for CreateMultipartUpload that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMultipartUploadOutcomeCallable CreateMultipartUploadCallable(const CreateMultipartUploadRequestT& request) const { return SubmitCallable(&S3Client::CreateMultipartUpload, request); } /** * An Async wrapper for CreateMultipartUpload that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMultipartUploadAsync(const CreateMultipartUploadRequestT& request, const CreateMultipartUploadResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::CreateMultipartUpload, request, handler, context); } /** *

Deletes the S3 bucket. All objects (including all object versions and delete * markers) in the bucket must be deleted before the bucket itself can be * deleted.

Related Resources

See Also:

AWS API * Reference

*/ virtual Model::DeleteBucketOutcome DeleteBucket(const Model::DeleteBucketRequest& request) const; /** * A Callable wrapper for DeleteBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketOutcomeCallable DeleteBucketCallable(const DeleteBucketRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucket, request); } /** * An Async wrapper for DeleteBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketAsync(const DeleteBucketRequestT& request, const DeleteBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucket, request, handler, context); } /** *

Deletes an analytics configuration for the bucket (specified by the analytics * configuration ID).

To use this operation, you must have permissions to * perform the s3:PutAnalyticsConfiguration action. The 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.

For information about * the Amazon S3 analytics feature, see Amazon * S3 Analytics – Storage Class Analysis.

The following operations are * related to DeleteBucketAnalyticsConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketAnalyticsConfigurationOutcome DeleteBucketAnalyticsConfiguration(const Model::DeleteBucketAnalyticsConfigurationRequest& request) const; /** * A Callable wrapper for DeleteBucketAnalyticsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketAnalyticsConfigurationOutcomeCallable DeleteBucketAnalyticsConfigurationCallable(const DeleteBucketAnalyticsConfigurationRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketAnalyticsConfiguration, request); } /** * An Async wrapper for DeleteBucketAnalyticsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketAnalyticsConfigurationAsync(const DeleteBucketAnalyticsConfigurationRequestT& request, const DeleteBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketAnalyticsConfiguration, request, handler, context); } /** *

Deletes the cors configuration information set for the * bucket.

To use this operation, you must have permission to perform the * s3:PutBucketCORS action. The bucket owner has this permission by * default and can grant this permission to others.

For information about * cors, see Enabling * Cross-Origin Resource Sharing in the Amazon S3 User Guide.

Related Resources:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketCorsOutcome DeleteBucketCors(const Model::DeleteBucketCorsRequest& request) const; /** * A Callable wrapper for DeleteBucketCors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketCorsOutcomeCallable DeleteBucketCorsCallable(const DeleteBucketCorsRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketCors, request); } /** * An Async wrapper for DeleteBucketCors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketCorsAsync(const DeleteBucketCorsRequestT& request, const DeleteBucketCorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketCors, request, handler, context); } /** *

This implementation of the DELETE action removes default encryption from the * bucket. For information about the Amazon S3 default encryption feature, see Amazon * S3 Default Bucket Encryption in the Amazon S3 User Guide.

To * use this operation, you must have permissions to perform the * s3:PutEncryptionConfiguration action. The 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 in the Amazon S3 User * Guide.

Related Resources

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketEncryptionOutcome DeleteBucketEncryption(const Model::DeleteBucketEncryptionRequest& request) const; /** * A Callable wrapper for DeleteBucketEncryption that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketEncryptionOutcomeCallable DeleteBucketEncryptionCallable(const DeleteBucketEncryptionRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketEncryption, request); } /** * An Async wrapper for DeleteBucketEncryption that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketEncryptionAsync(const DeleteBucketEncryptionRequestT& request, const DeleteBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketEncryption, request, handler, context); } /** *

Deletes the S3 Intelligent-Tiering configuration from the specified * bucket.

The S3 Intelligent-Tiering storage class is designed to optimize * storage costs by automatically moving data to the most cost-effective storage * access tier, without performance impact or operational overhead. S3 * Intelligent-Tiering delivers automatic cost savings in three low latency and * high throughput access tiers. To get the lowest storage cost on data that can be * accessed in minutes to hours, you can choose to activate additional archiving * capabilities.

The S3 Intelligent-Tiering storage class is the ideal * storage class for data with unknown, changing, or unpredictable access patterns, * independent of object size or retention period. If the size of an object is less * than 128 KB, it is not monitored and not eligible for auto-tiering. Smaller * objects can be stored, but they are always charged at the Frequent Access tier * rates in the S3 Intelligent-Tiering storage class.

For more information, * see Storage * class for automatically optimizing frequently and infrequently accessed * objects.

Operations related to * DeleteBucketIntelligentTieringConfiguration include:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketIntelligentTieringConfigurationOutcome DeleteBucketIntelligentTieringConfiguration(const Model::DeleteBucketIntelligentTieringConfigurationRequest& request) const; /** * A Callable wrapper for DeleteBucketIntelligentTieringConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketIntelligentTieringConfigurationOutcomeCallable DeleteBucketIntelligentTieringConfigurationCallable(const DeleteBucketIntelligentTieringConfigurationRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketIntelligentTieringConfiguration, request); } /** * An Async wrapper for DeleteBucketIntelligentTieringConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketIntelligentTieringConfigurationAsync(const DeleteBucketIntelligentTieringConfigurationRequestT& request, const DeleteBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketIntelligentTieringConfiguration, request, handler, context); } /** *

Deletes an inventory configuration (identified by the inventory ID) from the * bucket.

To use this operation, you must have permissions to perform the * s3:PutInventoryConfiguration action. The 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.

For information about * the Amazon S3 inventory feature, see Amazon * S3 Inventory.

Operations related to * DeleteBucketInventoryConfiguration include:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketInventoryConfigurationOutcome DeleteBucketInventoryConfiguration(const Model::DeleteBucketInventoryConfigurationRequest& request) const; /** * A Callable wrapper for DeleteBucketInventoryConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketInventoryConfigurationOutcomeCallable DeleteBucketInventoryConfigurationCallable(const DeleteBucketInventoryConfigurationRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketInventoryConfiguration, request); } /** * An Async wrapper for DeleteBucketInventoryConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketInventoryConfigurationAsync(const DeleteBucketInventoryConfigurationRequestT& request, const DeleteBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketInventoryConfiguration, request, handler, context); } /** *

Deletes the lifecycle configuration from the specified bucket. Amazon S3 * removes all the lifecycle configuration rules in the lifecycle subresource * associated with the bucket. Your objects never expire, and Amazon S3 no longer * automatically deletes any objects on the basis of rules contained in the deleted * lifecycle configuration.

To use this operation, you must have permission * to perform the s3:PutLifecycleConfiguration action. By default, the * bucket owner has this permission and the bucket owner can grant this permission * to others.

There is usually some time lag before lifecycle configuration * deletion is fully propagated to all the Amazon S3 systems.

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

Related actions include:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketLifecycleOutcome DeleteBucketLifecycle(const Model::DeleteBucketLifecycleRequest& request) const; /** * A Callable wrapper for DeleteBucketLifecycle that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketLifecycleOutcomeCallable DeleteBucketLifecycleCallable(const DeleteBucketLifecycleRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketLifecycle, request); } /** * An Async wrapper for DeleteBucketLifecycle that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketLifecycleAsync(const DeleteBucketLifecycleRequestT& request, const DeleteBucketLifecycleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketLifecycle, request, handler, context); } /** *

Deletes a metrics configuration for the Amazon CloudWatch request metrics * (specified by the metrics configuration ID) from the bucket. Note that this * doesn't include the daily storage metrics.

To use this operation, you * must have permissions to perform the s3:PutMetricsConfiguration * action. The 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.

For information about * CloudWatch request metrics for Amazon S3, see Monitoring * Metrics with Amazon CloudWatch.

The following operations are related * to DeleteBucketMetricsConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketMetricsConfigurationOutcome DeleteBucketMetricsConfiguration(const Model::DeleteBucketMetricsConfigurationRequest& request) const; /** * A Callable wrapper for DeleteBucketMetricsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketMetricsConfigurationOutcomeCallable DeleteBucketMetricsConfigurationCallable(const DeleteBucketMetricsConfigurationRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketMetricsConfiguration, request); } /** * An Async wrapper for DeleteBucketMetricsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketMetricsConfigurationAsync(const DeleteBucketMetricsConfigurationRequestT& request, const DeleteBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketMetricsConfiguration, request, handler, context); } /** *

Removes OwnershipControls for an Amazon S3 bucket. To use this * operation, you must have the s3:PutBucketOwnershipControls * permission. For more information about Amazon S3 permissions, see Specifying * Permissions in a Policy.

For information about Amazon S3 Object * Ownership, see Using * Object Ownership.

The following operations are related to * DeleteBucketOwnershipControls:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketOwnershipControlsOutcome DeleteBucketOwnershipControls(const Model::DeleteBucketOwnershipControlsRequest& request) const; /** * A Callable wrapper for DeleteBucketOwnershipControls that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketOwnershipControlsOutcomeCallable DeleteBucketOwnershipControlsCallable(const DeleteBucketOwnershipControlsRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketOwnershipControls, request); } /** * An Async wrapper for DeleteBucketOwnershipControls that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketOwnershipControlsAsync(const DeleteBucketOwnershipControlsRequestT& request, const DeleteBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketOwnershipControls, request, handler, context); } /** *

This implementation of the DELETE action uses the policy subresource to * delete the policy of a specified 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 DeleteBucketPolicy permissions on * the specified bucket and belong to the bucket owner's account to use this * operation.

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 * operation, 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 UserPolicies.

The following operations are * related to DeleteBucketPolicy

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketPolicyOutcome DeleteBucketPolicy(const Model::DeleteBucketPolicyRequest& request) const; /** * A Callable wrapper for DeleteBucketPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketPolicyOutcomeCallable DeleteBucketPolicyCallable(const DeleteBucketPolicyRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketPolicy, request); } /** * An Async wrapper for DeleteBucketPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketPolicyAsync(const DeleteBucketPolicyRequestT& request, const DeleteBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketPolicy, request, handler, context); } /** *

Deletes the replication configuration from the bucket.

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

It can take a * while for the deletion of a replication configuration to fully propagate.

*

For information about replication configuration, see Replication * in the Amazon S3 User Guide.

The following operations are related * to DeleteBucketReplication:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketReplicationOutcome DeleteBucketReplication(const Model::DeleteBucketReplicationRequest& request) const; /** * A Callable wrapper for DeleteBucketReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketReplicationOutcomeCallable DeleteBucketReplicationCallable(const DeleteBucketReplicationRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketReplication, request); } /** * An Async wrapper for DeleteBucketReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketReplicationAsync(const DeleteBucketReplicationRequestT& request, const DeleteBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketReplication, request, handler, context); } /** *

Deletes the tags from the bucket.

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

The following operations are related to * DeleteBucketTagging:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketTaggingOutcome DeleteBucketTagging(const Model::DeleteBucketTaggingRequest& request) const; /** * A Callable wrapper for DeleteBucketTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketTaggingOutcomeCallable DeleteBucketTaggingCallable(const DeleteBucketTaggingRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketTagging, request); } /** * An Async wrapper for DeleteBucketTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketTaggingAsync(const DeleteBucketTaggingRequestT& request, const DeleteBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketTagging, request, handler, context); } /** *

This action removes the website configuration for a bucket. Amazon S3 returns * a 200 OK response upon successfully deleting a website * configuration on the specified bucket. You will get a 200 OK * response if the website configuration you are trying to delete does not exist on * the bucket. Amazon S3 returns a 404 response if the bucket * specified in the request does not exist.

This DELETE action requires the * S3:DeleteBucketWebsite permission. By default, only the bucket * owner can delete the website configuration attached to a bucket. However, bucket * owners can grant other users permission to delete the website configuration by * writing a bucket policy granting them the S3:DeleteBucketWebsite * permission.

For more information about hosting websites, see Hosting * Websites on Amazon S3.

The following operations are related to * DeleteBucketWebsite:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketWebsiteOutcome DeleteBucketWebsite(const Model::DeleteBucketWebsiteRequest& request) const; /** * A Callable wrapper for DeleteBucketWebsite that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketWebsiteOutcomeCallable DeleteBucketWebsiteCallable(const DeleteBucketWebsiteRequestT& request) const { return SubmitCallable(&S3Client::DeleteBucketWebsite, request); } /** * An Async wrapper for DeleteBucketWebsite that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketWebsiteAsync(const DeleteBucketWebsiteRequestT& request, const DeleteBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteBucketWebsite, request, handler, context); } /** *

Removes the null version (if there is one) of an object and inserts a delete * marker, which becomes the latest version of the object. If there isn't a null * version, Amazon S3 does not remove any objects but will still respond that the * command was successful.

To remove a specific version, you must be the * bucket owner and you must use the version Id subresource. Using this subresource * permanently deletes the version. If the object deleted is a delete marker, * Amazon S3 sets the response header, x-amz-delete-marker, to true. *

If the object you want to delete is in a bucket where the bucket * versioning configuration is MFA Delete enabled, you must include the * x-amz-mfa request header in the DELETE versionId * request. Requests that include x-amz-mfa must use HTTPS.

* For more information about MFA Delete, see Using * MFA Delete. To see sample requests that use versioning, see Sample * Request.

You can delete objects by explicitly calling DELETE Object * or configure its lifecycle (PutBucketLifecycle) * to enable Amazon S3 to remove them for you. If you want to block users or * accounts from removing or deleting objects from your bucket, you must deny them * the s3:DeleteObject, s3:DeleteObjectVersion, and * s3:PutLifeCycleConfiguration actions.

The following action * is related to DeleteObject:

See Also:

AWS API * Reference

*/ virtual Model::DeleteObjectOutcome DeleteObject(const Model::DeleteObjectRequest& request) const; /** * A Callable wrapper for DeleteObject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteObjectOutcomeCallable DeleteObjectCallable(const DeleteObjectRequestT& request) const { return SubmitCallable(&S3Client::DeleteObject, request); } /** * An Async wrapper for DeleteObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteObjectAsync(const DeleteObjectRequestT& request, const DeleteObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteObject, request, handler, context); } /** *

Removes the entire tag set from the specified object. For more information * about managing object tags, see * Object Tagging.

To use this operation, you must have permission to * perform the s3:DeleteObjectTagging action.

To delete tags of * a specific object version, add the versionId query parameter in the * request. You will need permission for the * s3:DeleteObjectVersionTagging action.

The following * operations are related to DeleteBucketMetricsConfiguration:

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteObjectTaggingOutcome DeleteObjectTagging(const Model::DeleteObjectTaggingRequest& request) const; /** * A Callable wrapper for DeleteObjectTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteObjectTaggingOutcomeCallable DeleteObjectTaggingCallable(const DeleteObjectTaggingRequestT& request) const { return SubmitCallable(&S3Client::DeleteObjectTagging, request); } /** * An Async wrapper for DeleteObjectTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteObjectTaggingAsync(const DeleteObjectTaggingRequestT& request, const DeleteObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteObjectTagging, request, handler, context); } /** *

This action enables you to delete multiple objects from a bucket using a * single HTTP request. If you know the object keys that you want to delete, then * this action provides a suitable alternative to sending individual delete * requests, reducing per-request overhead.

The request contains a list of * up to 1000 keys that you want to delete. In the XML, you provide the object key * names, and optionally, version IDs if you want to delete a specific version of * the object from a versioning-enabled bucket. For each key, Amazon S3 performs a * delete action and returns the result of that delete, success, or failure, in the * response. Note that if the object specified in the request is not found, Amazon * S3 returns the result as deleted.

The action supports two modes for the * response: verbose and quiet. By default, the action uses verbose mode in which * the response includes the result of deletion of each key in your request. In * quiet mode the response includes only keys where the delete action encountered * an error. For a successful deletion, the action does not return any information * about the delete in the response body.

When performing this action on an * MFA Delete enabled bucket, that attempts to delete any versioned objects, you * must include an MFA token. If you do not provide one, the entire request will * fail, even if there are non-versioned objects you are trying to delete. If you * provide an invalid token, whether there are versioned keys in the request or * not, the entire Multi-Object Delete request will fail. For information about MFA * Delete, see * MFA Delete.

Finally, the Content-MD5 header is required for all * Multi-Object Delete requests. Amazon S3 uses the header value to ensure that * your request body has not been altered in transit.

The following * operations are related to DeleteObjects:

See Also:

AWS * API Reference

*/ virtual Model::DeleteObjectsOutcome DeleteObjects(const Model::DeleteObjectsRequest& request) const; /** * A Callable wrapper for DeleteObjects that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteObjectsOutcomeCallable DeleteObjectsCallable(const DeleteObjectsRequestT& request) const { return SubmitCallable(&S3Client::DeleteObjects, request); } /** * An Async wrapper for DeleteObjects that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteObjectsAsync(const DeleteObjectsRequestT& request, const DeleteObjectsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeleteObjects, request, handler, context); } /** *

Removes the PublicAccessBlock configuration for an Amazon S3 * bucket. To use this operation, you must have the * s3:PutBucketPublicAccessBlock permission. For more information * about permissions, see Permissions * Related to Bucket Subresource Operations and Managing * Access Permissions to Your Amazon S3 Resources.

The following * operations are related to DeletePublicAccessBlock:

See Also:

AWS * API Reference

*/ virtual Model::DeletePublicAccessBlockOutcome DeletePublicAccessBlock(const Model::DeletePublicAccessBlockRequest& request) const; /** * A Callable wrapper for DeletePublicAccessBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePublicAccessBlockOutcomeCallable DeletePublicAccessBlockCallable(const DeletePublicAccessBlockRequestT& request) const { return SubmitCallable(&S3Client::DeletePublicAccessBlock, request); } /** * An Async wrapper for DeletePublicAccessBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePublicAccessBlockAsync(const DeletePublicAccessBlockRequestT& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::DeletePublicAccessBlock, request, handler, context); } /** *

This implementation of the GET action uses the accelerate * subresource to return the Transfer Acceleration state of a bucket, which is * either Enabled or Suspended. Amazon S3 Transfer * Acceleration is a bucket-level feature that enables you to perform faster data * transfers to and from Amazon S3.

To use this operation, you must have * permission to perform the s3:GetAccelerateConfiguration action. The * 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 in the Amazon S3 User * Guide.

You set the Transfer Acceleration state of an existing bucket * to Enabled or Suspended by using the PutBucketAccelerateConfiguration * operation.

A GET accelerate request does not return a state * value for a bucket that has no transfer acceleration state. A bucket has no * Transfer Acceleration state if a state has never been set on the bucket.

*

For more information about transfer acceleration, see Transfer * Acceleration in the Amazon S3 User Guide.

Related * Resources

See Also:

AWS * API Reference

*/ virtual Model::GetBucketAccelerateConfigurationOutcome GetBucketAccelerateConfiguration(const Model::GetBucketAccelerateConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketAccelerateConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketAccelerateConfigurationOutcomeCallable GetBucketAccelerateConfigurationCallable(const GetBucketAccelerateConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketAccelerateConfiguration, request); } /** * An Async wrapper for GetBucketAccelerateConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketAccelerateConfigurationAsync(const GetBucketAccelerateConfigurationRequestT& request, const GetBucketAccelerateConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketAccelerateConfiguration, request, handler, context); } /** *

This implementation of the GET action uses the acl * subresource to return the access control list (ACL) of a bucket. To use * GET to return the ACL of the bucket, you must have * READ_ACP access to the bucket. If READ_ACP permission * is granted to the anonymous user, you can return the ACL of the bucket without * using an authorization header.

If your bucket uses the bucket * owner enforced setting for S3 Object Ownership, requests to read ACLs are still * supported and return the bucket-owner-full-control ACL with the * owner being the account that created the bucket. For more information, see * Controlling object ownership and disabling ACLs in the Amazon S3 User * Guide.

Related Resources

See Also:

AWS API * Reference

*/ virtual Model::GetBucketAclOutcome GetBucketAcl(const Model::GetBucketAclRequest& request) const; /** * A Callable wrapper for GetBucketAcl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketAclOutcomeCallable GetBucketAclCallable(const GetBucketAclRequestT& request) const { return SubmitCallable(&S3Client::GetBucketAcl, request); } /** * An Async wrapper for GetBucketAcl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketAclAsync(const GetBucketAclRequestT& request, const GetBucketAclResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketAcl, request, handler, context); } /** *

This implementation of the GET action returns an analytics configuration * (identified by the analytics configuration ID) from the bucket.

To use * this operation, you must have permissions to perform the * s3:GetAnalyticsConfiguration action. The 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 in the Amazon S3 User * Guide.

For information about Amazon S3 analytics feature, see Amazon * S3 Analytics – Storage Class Analysis in the Amazon S3 User * Guide.

Related Resources

See Also:

AWS * API Reference

*/ virtual Model::GetBucketAnalyticsConfigurationOutcome GetBucketAnalyticsConfiguration(const Model::GetBucketAnalyticsConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketAnalyticsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketAnalyticsConfigurationOutcomeCallable GetBucketAnalyticsConfigurationCallable(const GetBucketAnalyticsConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketAnalyticsConfiguration, request); } /** * An Async wrapper for GetBucketAnalyticsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketAnalyticsConfigurationAsync(const GetBucketAnalyticsConfigurationRequestT& request, const GetBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketAnalyticsConfiguration, request, handler, context); } /** *

Returns the Cross-Origin Resource Sharing (CORS) configuration information * set for the bucket.

To use this operation, you must have permission to * perform the s3:GetBucketCORS action. By default, the bucket owner * has this permission and can grant it to others.

For more information * about CORS, see Enabling * Cross-Origin Resource Sharing.

The following operations are related * to GetBucketCors:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketCorsOutcome GetBucketCors(const Model::GetBucketCorsRequest& request) const; /** * A Callable wrapper for GetBucketCors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketCorsOutcomeCallable GetBucketCorsCallable(const GetBucketCorsRequestT& request) const { return SubmitCallable(&S3Client::GetBucketCors, request); } /** * An Async wrapper for GetBucketCors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketCorsAsync(const GetBucketCorsRequestT& request, const GetBucketCorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketCors, request, handler, context); } /** *

Returns the default encryption configuration for an Amazon S3 bucket. If the * bucket does not have a default encryption configuration, GetBucketEncryption * returns ServerSideEncryptionConfigurationNotFoundError.

For * information about the Amazon S3 default encryption feature, see Amazon * S3 Default Bucket Encryption.

To use this operation, you must have * permission to perform the s3:GetEncryptionConfiguration action. The * 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.

The following * operations are related to GetBucketEncryption:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketEncryptionOutcome GetBucketEncryption(const Model::GetBucketEncryptionRequest& request) const; /** * A Callable wrapper for GetBucketEncryption that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketEncryptionOutcomeCallable GetBucketEncryptionCallable(const GetBucketEncryptionRequestT& request) const { return SubmitCallable(&S3Client::GetBucketEncryption, request); } /** * An Async wrapper for GetBucketEncryption that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketEncryptionAsync(const GetBucketEncryptionRequestT& request, const GetBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketEncryption, request, handler, context); } /** *

Gets the S3 Intelligent-Tiering configuration from the specified bucket.

*

The S3 Intelligent-Tiering storage class is designed to optimize storage * costs by automatically moving data to the most cost-effective storage access * tier, without performance impact or operational overhead. S3 Intelligent-Tiering * delivers automatic cost savings in three low latency and high throughput access * tiers. To get the lowest storage cost on data that can be accessed in minutes to * hours, you can choose to activate additional archiving capabilities.

The * S3 Intelligent-Tiering storage class is the ideal storage class for data with * unknown, changing, or unpredictable access patterns, independent of object size * or retention period. If the size of an object is less than 128 KB, it is not * monitored and not eligible for auto-tiering. Smaller objects can be stored, but * they are always charged at the Frequent Access tier rates in the S3 * Intelligent-Tiering storage class.

For more information, see Storage * class for automatically optimizing frequently and infrequently accessed * objects.

Operations related to * GetBucketIntelligentTieringConfiguration include:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketIntelligentTieringConfigurationOutcome GetBucketIntelligentTieringConfiguration(const Model::GetBucketIntelligentTieringConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketIntelligentTieringConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketIntelligentTieringConfigurationOutcomeCallable GetBucketIntelligentTieringConfigurationCallable(const GetBucketIntelligentTieringConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketIntelligentTieringConfiguration, request); } /** * An Async wrapper for GetBucketIntelligentTieringConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketIntelligentTieringConfigurationAsync(const GetBucketIntelligentTieringConfigurationRequestT& request, const GetBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketIntelligentTieringConfiguration, request, handler, context); } /** *

Returns an inventory configuration (identified by the inventory configuration * ID) from the bucket.

To use this operation, you must have permissions to * perform the s3:GetInventoryConfiguration action. The 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.

For information about * the Amazon S3 inventory feature, see Amazon * S3 Inventory.

The following operations are related to * GetBucketInventoryConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketInventoryConfigurationOutcome GetBucketInventoryConfiguration(const Model::GetBucketInventoryConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketInventoryConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketInventoryConfigurationOutcomeCallable GetBucketInventoryConfigurationCallable(const GetBucketInventoryConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketInventoryConfiguration, request); } /** * An Async wrapper for GetBucketInventoryConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketInventoryConfigurationAsync(const GetBucketInventoryConfigurationRequestT& request, const GetBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketInventoryConfiguration, request, handler, context); } /** *

Bucket lifecycle configuration now supports specifying a lifecycle * rule using an object key name prefix, one or more object tags, or a combination * of both. Accordingly, this section describes the latest API. The response * describes the new filter element that you can use to specify a filter to select * a subset of objects to which the rule applies. If you are using a previous * version of the lifecycle configuration, it still works. For the earlier action, * see GetBucketLifecycle.

*

Returns the lifecycle configuration information set on the bucket. * For information about lifecycle configuration, see Object * Lifecycle Management.

To use this operation, you must have permission * to perform the s3:GetLifecycleConfiguration action. The 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.

* 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 operations are * related to GetBucketLifecycleConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketLifecycleConfigurationOutcome GetBucketLifecycleConfiguration(const Model::GetBucketLifecycleConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketLifecycleConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketLifecycleConfigurationOutcomeCallable GetBucketLifecycleConfigurationCallable(const GetBucketLifecycleConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketLifecycleConfiguration, request); } /** * An Async wrapper for GetBucketLifecycleConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketLifecycleConfigurationAsync(const GetBucketLifecycleConfigurationRequestT& request, const GetBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketLifecycleConfiguration, request, handler, context); } /** *

Returns the Region the bucket resides in. You set the bucket's Region using * the LocationConstraint request parameter in a * CreateBucket request. For more information, see CreateBucket.

*

To use this implementation of the operation, you must be the bucket * owner.

To use this API against an access point, provide the alias of the * access point in place of the bucket name.

The following operations are * related to GetBucketLocation:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketLocationOutcome GetBucketLocation(const Model::GetBucketLocationRequest& request) const; /** * A Callable wrapper for GetBucketLocation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketLocationOutcomeCallable GetBucketLocationCallable(const GetBucketLocationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketLocation, request); } /** * An Async wrapper for GetBucketLocation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketLocationAsync(const GetBucketLocationRequestT& request, const GetBucketLocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketLocation, request, handler, context); } /** *

Returns the logging status of a bucket and the permissions users have to view * and modify that status. To use GET, you must be the bucket owner.

The * following operations are related to GetBucketLogging:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketLoggingOutcome GetBucketLogging(const Model::GetBucketLoggingRequest& request) const; /** * A Callable wrapper for GetBucketLogging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketLoggingOutcomeCallable GetBucketLoggingCallable(const GetBucketLoggingRequestT& request) const { return SubmitCallable(&S3Client::GetBucketLogging, request); } /** * An Async wrapper for GetBucketLogging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketLoggingAsync(const GetBucketLoggingRequestT& request, const GetBucketLoggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketLogging, request, handler, context); } /** *

Gets a metrics configuration (specified by the metrics configuration ID) from * the bucket. Note that this doesn't include the daily storage metrics.

To * use this operation, you must have permissions to perform the * s3:GetMetricsConfiguration action. The 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.

For information * about CloudWatch request metrics for Amazon S3, see Monitoring * Metrics with Amazon CloudWatch.

The following operations are related * to GetBucketMetricsConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketMetricsConfigurationOutcome GetBucketMetricsConfiguration(const Model::GetBucketMetricsConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketMetricsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketMetricsConfigurationOutcomeCallable GetBucketMetricsConfigurationCallable(const GetBucketMetricsConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketMetricsConfiguration, request); } /** * An Async wrapper for GetBucketMetricsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketMetricsConfigurationAsync(const GetBucketMetricsConfigurationRequestT& request, const GetBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketMetricsConfiguration, request, handler, context); } /** *

Returns the notification configuration of a bucket.

If notifications * are not enabled on the bucket, the action returns an empty * NotificationConfiguration element.

By default, you must be * the bucket owner to read the notification configuration of a bucket. However, * the bucket owner can use a bucket policy to grant permission to other users to * read this configuration with the s3:GetBucketNotification * permission.

For more information about setting and reading the * notification configuration on a bucket, see Setting * Up Notification of Bucket Events. For more information about bucket * policies, see Using * Bucket Policies.

The following action is related to * GetBucketNotification:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketNotificationConfigurationOutcome GetBucketNotificationConfiguration(const Model::GetBucketNotificationConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketNotificationConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketNotificationConfigurationOutcomeCallable GetBucketNotificationConfigurationCallable(const GetBucketNotificationConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketNotificationConfiguration, request); } /** * An Async wrapper for GetBucketNotificationConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketNotificationConfigurationAsync(const GetBucketNotificationConfigurationRequestT& request, const GetBucketNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketNotificationConfiguration, request, handler, context); } /** *

Retrieves OwnershipControls for an Amazon S3 bucket. To use this * operation, you must have the s3:GetBucketOwnershipControls * permission. For more information about Amazon S3 permissions, see Specifying * permissions in a policy.

For information about Amazon S3 Object * Ownership, see Using * Object Ownership.

The following operations are related to * GetBucketOwnershipControls:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketOwnershipControlsOutcome GetBucketOwnershipControls(const Model::GetBucketOwnershipControlsRequest& request) const; /** * A Callable wrapper for GetBucketOwnershipControls that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketOwnershipControlsOutcomeCallable GetBucketOwnershipControlsCallable(const GetBucketOwnershipControlsRequestT& request) const { return SubmitCallable(&S3Client::GetBucketOwnershipControls, request); } /** * An Async wrapper for GetBucketOwnershipControls that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketOwnershipControlsAsync(const GetBucketOwnershipControlsRequestT& request, const GetBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketOwnershipControls, request, handler, context); } /** *

Returns the policy of a specified 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 GetBucketPolicy permissions on the * specified bucket and belong to the bucket owner's account in order to use this * operation.

If you don't have GetBucketPolicy 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 operation, 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.

The following action is related to * GetBucketPolicy:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketPolicyOutcome GetBucketPolicy(const Model::GetBucketPolicyRequest& request) const; /** * A Callable wrapper for GetBucketPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketPolicyOutcomeCallable GetBucketPolicyCallable(const GetBucketPolicyRequestT& request) const { return SubmitCallable(&S3Client::GetBucketPolicy, request); } /** * An Async wrapper for GetBucketPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketPolicyAsync(const GetBucketPolicyRequestT& request, const GetBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketPolicy, request, handler, context); } /** *

Retrieves the policy status for an Amazon S3 bucket, indicating whether the * bucket is public. In order to use this operation, you must have the * s3:GetBucketPolicyStatus permission. For more information about * Amazon S3 permissions, see Specifying * Permissions in a Policy.

For more information about when Amazon S3 * considers a bucket public, see The * Meaning of "Public".

The following operations are related to * GetBucketPolicyStatus:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketPolicyStatusOutcome GetBucketPolicyStatus(const Model::GetBucketPolicyStatusRequest& request) const; /** * A Callable wrapper for GetBucketPolicyStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketPolicyStatusOutcomeCallable GetBucketPolicyStatusCallable(const GetBucketPolicyStatusRequestT& request) const { return SubmitCallable(&S3Client::GetBucketPolicyStatus, request); } /** * An Async wrapper for GetBucketPolicyStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketPolicyStatusAsync(const GetBucketPolicyStatusRequestT& request, const GetBucketPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketPolicyStatus, request, handler, context); } /** *

Returns the replication configuration of a bucket.

It can take * a while to propagate the put or delete a replication configuration to all Amazon * S3 systems. Therefore, a get request soon after put or delete can return a wrong * result.

For information about replication configuration, see Replication * in the Amazon S3 User Guide.

This action requires permissions for * the s3:GetReplicationConfiguration action. For more information * about permissions, see Using * Bucket Policies and User Policies.

If you include the * Filter element in a replication configuration, you must also * include the DeleteMarkerReplication and Priority * elements. The response also returns those elements.

For information about * GetBucketReplication errors, see List * of replication-related error codes

The following operations are * related to GetBucketReplication:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketReplicationOutcome GetBucketReplication(const Model::GetBucketReplicationRequest& request) const; /** * A Callable wrapper for GetBucketReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketReplicationOutcomeCallable GetBucketReplicationCallable(const GetBucketReplicationRequestT& request) const { return SubmitCallable(&S3Client::GetBucketReplication, request); } /** * An Async wrapper for GetBucketReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketReplicationAsync(const GetBucketReplicationRequestT& request, const GetBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketReplication, request, handler, context); } /** *

Returns the request payment configuration of a bucket. To use this version of * the operation, you must be the bucket owner. For more information, see Requester * Pays Buckets.

The following operations are related to * GetBucketRequestPayment:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketRequestPaymentOutcome GetBucketRequestPayment(const Model::GetBucketRequestPaymentRequest& request) const; /** * A Callable wrapper for GetBucketRequestPayment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketRequestPaymentOutcomeCallable GetBucketRequestPaymentCallable(const GetBucketRequestPaymentRequestT& request) const { return SubmitCallable(&S3Client::GetBucketRequestPayment, request); } /** * An Async wrapper for GetBucketRequestPayment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketRequestPaymentAsync(const GetBucketRequestPaymentRequestT& request, const GetBucketRequestPaymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketRequestPayment, request, handler, context); } /** *

Returns the tag set associated with the bucket.

To use this operation, * you must have permission to perform the s3: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: NoSuchTagSet

    • *

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

    *

The following operations are related to * GetBucketTagging:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketTaggingOutcome GetBucketTagging(const Model::GetBucketTaggingRequest& request) const; /** * A Callable wrapper for GetBucketTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketTaggingOutcomeCallable GetBucketTaggingCallable(const GetBucketTaggingRequestT& request) const { return SubmitCallable(&S3Client::GetBucketTagging, request); } /** * An Async wrapper for GetBucketTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketTaggingAsync(const GetBucketTaggingRequestT& request, const GetBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketTagging, request, handler, context); } /** *

Returns the versioning state of a bucket.

To retrieve the versioning * state of a bucket, you must be the bucket owner.

This implementation also * returns the MFA Delete status of the versioning state. If the MFA Delete status * is enabled, the bucket owner must use an authentication device to * change the versioning state of the bucket.

The following operations are * related to GetBucketVersioning:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketVersioningOutcome GetBucketVersioning(const Model::GetBucketVersioningRequest& request) const; /** * A Callable wrapper for GetBucketVersioning that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketVersioningOutcomeCallable GetBucketVersioningCallable(const GetBucketVersioningRequestT& request) const { return SubmitCallable(&S3Client::GetBucketVersioning, request); } /** * An Async wrapper for GetBucketVersioning that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketVersioningAsync(const GetBucketVersioningRequestT& request, const GetBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketVersioning, request, handler, context); } /** *

Returns the website configuration for a bucket. To host website on Amazon S3, * you can configure a bucket as website by adding a website configuration. For * more information about hosting websites, see Hosting * Websites on Amazon S3.

This GET action requires the * S3:GetBucketWebsite permission. By default, only the bucket owner * can read the bucket website configuration. However, bucket owners can allow * other users to read the website configuration by writing a bucket policy * granting them the S3:GetBucketWebsite permission.

The * following operations are related to DeleteBucketWebsite:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketWebsiteOutcome GetBucketWebsite(const Model::GetBucketWebsiteRequest& request) const; /** * A Callable wrapper for GetBucketWebsite that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketWebsiteOutcomeCallable GetBucketWebsiteCallable(const GetBucketWebsiteRequestT& request) const { return SubmitCallable(&S3Client::GetBucketWebsite, request); } /** * An Async wrapper for GetBucketWebsite that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketWebsiteAsync(const GetBucketWebsiteRequestT& request, const GetBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetBucketWebsite, request, handler, context); } /** *

Retrieves objects from Amazon S3. To use GET, you must have * READ access to the object. If you grant READ access to * the anonymous user, you can return the object without using an authorization * header.

An Amazon S3 bucket has no directory hierarchy such as you would * find in a typical computer file system. You can, however, create a logical * hierarchy by using object key names that imply a folder structure. For example, * instead of naming an object sample.jpg, you can name it * photos/2006/February/sample.jpg.

To get an object from such * a logical hierarchy, specify the full key name for the object in the * GET operation. For a virtual hosted-style request example, if you * have the object photos/2006/February/sample.jpg, specify the * resource as /photos/2006/February/sample.jpg. For a path-style * request example, if you have the object * photos/2006/February/sample.jpg in the bucket named * examplebucket, specify the resource as * /examplebucket/photos/2006/February/sample.jpg. For more * information about request types, see HTTP * Host Header Bucket Specification.

For more information about * returning the ACL of an object, see GetObjectAcl.

*

If the object you are retrieving is stored in the S3 Glacier or S3 Glacier * Deep Archive storage class, or S3 Intelligent-Tiering Archive or S3 * Intelligent-Tiering Deep Archive tiers, before you can retrieve the object you * must first restore a copy using RestoreObject. * Otherwise, this action returns an InvalidObjectStateError error. * For information about restoring archived objects, see Restoring * Archived Objects.

Encryption request headers, like * x-amz-server-side-encryption, should not be sent for GET requests * if your object uses server-side encryption with KMS keys (SSE-KMS) or * server-side encryption with Amazon S3–managed encryption keys (SSE-S3). If your * object does use these types of keys, you’ll get an HTTP 400 BadRequest * error.

If you encrypt an object by using server-side encryption with * customer-provided encryption keys (SSE-C) when you store the object in Amazon * S3, then when you GET the object, you must use the following headers:

    *

  • x-amz-server-side-encryption-customer-algorithm

  • *

    x-amz-server-side-encryption-customer-key

  • *

    x-amz-server-side-encryption-customer-key-MD5

For more * information about SSE-C, see Server-Side * Encryption (Using Customer-Provided Encryption Keys).

Assuming you * have the relevant permission to read object tags, the response also returns the * x-amz-tagging-count header that provides the count of number of * tags associated with the object. You can use GetObjectTagging * to retrieve the tag set associated with an object.

Permissions *

You need the relevant read object (or version) permission for this * operation. For more information, see Specifying * Permissions in a Policy. If the object you request does not exist, the error * Amazon S3 returns depends on whether you also have the * s3:ListBucket permission.

  • If you have the * s3:ListBucket permission on the bucket, Amazon S3 will return an * HTTP status code 404 ("no such key") error.

  • If you don’t have * the s3:ListBucket permission, Amazon S3 will return an HTTP status * code 403 ("access denied") error.

Versioning

*

By default, the GET action returns the current version of an object. To * return a different version, use the versionId subresource.

*

  • If you supply a versionId, you need the * s3:GetObjectVersion permission to access a specific version of an * object. If you request a specific version, you do not need to have the * s3:GetObject permission.

  • If the current version * of the object is a delete marker, Amazon S3 behaves as if the object was deleted * and includes x-amz-delete-marker: true in the response.

    • *

For more information about versioning, see PutBucketVersioning. *

Overriding Response Header Values

There are times when * you want to override certain response header values in a GET response. For * example, you might override the Content-Disposition response header * value in your GET request.

You can override values for a set of response * headers using the following query parameters. These response header values are * sent only on a successful request, that is, when status code 200 OK is returned. * The set of headers you can override using these parameters is a subset of the * headers that Amazon S3 accepts when you create an object. The response headers * that you can override for the GET response are Content-Type, * Content-Language, Expires, Cache-Control, * Content-Disposition, and Content-Encoding. To override * these header values in the GET response, you use the following request * parameters.

You must sign the request, either using an * Authorization header or a presigned URL, when using these parameters. They * cannot be used with an unsigned (anonymous) request.

  • * response-content-type

  • * response-content-language

  • * response-expires

  • * response-cache-control

  • * response-content-disposition

  • * response-content-encoding

Additional * Considerations about Request Headers

If both of the * If-Match and If-Unmodified-Since headers are present * in the request as follows: If-Match condition evaluates to * true, and; If-Unmodified-Since condition evaluates to * false; then, S3 returns 200 OK and the data requested.

If * both of the If-None-Match and If-Modified-Since * headers are present in the request as follows: If-None-Match * condition evaluates to false, and; If-Modified-Since * condition evaluates to true; then, S3 returns 304 Not Modified * response code.

For more information about conditional requests, see RFC 7232.

The following * operations are related to GetObject:

See Also:

AWS API * Reference

*/ virtual Model::GetObjectOutcome GetObject(const Model::GetObjectRequest& request) const; /** * A Callable wrapper for GetObject that returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::GetObjectOutcomeCallable GetObjectCallable(const Model::GetObjectRequest& request) const; /** * An Async wrapper for GetObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void GetObjectAsync(const Model::GetObjectRequest& request, const GetObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Returns the access control list (ACL) of an object. To use this operation, * you must have s3:GetObjectAcl permissions or READ_ACP * access to the object. For more information, see Mapping * of ACL permissions and access policy permissions in the Amazon S3 User * Guide

This action is not supported by Amazon S3 on Outposts.

* Versioning

By default, GET returns ACL information about the * current version of an object. To return ACL information about a different * version, use the versionId subresource.

If your bucket uses the * bucket owner enforced setting for S3 Object Ownership, requests to read ACLs are * still supported and return the bucket-owner-full-control ACL with * the owner being the account that created the bucket. For more information, see * * Controlling object ownership and disabling ACLs in the Amazon S3 User * Guide.

The following operations are related to * GetObjectAcl:

See Also:

AWS API * Reference

*/ virtual Model::GetObjectAclOutcome GetObjectAcl(const Model::GetObjectAclRequest& request) const; /** * A Callable wrapper for GetObjectAcl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetObjectAclOutcomeCallable GetObjectAclCallable(const GetObjectAclRequestT& request) const { return SubmitCallable(&S3Client::GetObjectAcl, request); } /** * An Async wrapper for GetObjectAcl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetObjectAclAsync(const GetObjectAclRequestT& request, const GetObjectAclResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetObjectAcl, request, handler, context); } /** *

Retrieves all the metadata from an object without returning the object * itself. This action is useful if you're interested only in an object's metadata. * To use GetObjectAttributes, you must have READ access to the * object.

GetObjectAttributes combines the functionality of * GetObjectAcl, GetObjectLegalHold, * GetObjectLockConfiguration, GetObjectRetention, * GetObjectTagging, HeadObject, and * ListParts. All of the data returned with each of those individual * calls can be returned with a single call to * GetObjectAttributes.

If you encrypt an object by using * server-side encryption with customer-provided encryption keys (SSE-C) when you * store the object in Amazon S3, then when you retrieve the metadata from the * object, you must use the following headers:

  • * x-amz-server-side-encryption-customer-algorithm

  • * x-amz-server-side-encryption-customer-key

  • * x-amz-server-side-encryption-customer-key-MD5

*

For more information about SSE-C, see Server-Side * Encryption (Using Customer-Provided Encryption Keys) in the Amazon S3 * User Guide.

  • Encryption request headers, such as * x-amz-server-side-encryption, should not be sent for GET requests * if your object uses server-side encryption with Amazon Web Services KMS keys * stored in Amazon Web Services Key Management Service (SSE-KMS) or server-side * encryption with Amazon S3 managed encryption keys (SSE-S3). If your object does * use these types of keys, you'll get an HTTP 400 Bad Request * error.

  • The last modified property in this case is the * creation date of the object.

Consider the following * when using request headers:

  • If both of the * If-Match and If-Unmodified-Since headers are present * in the request as follows, then Amazon S3 returns the HTTP status code 200 * OK and the data requested:

    • If-Match * condition evaluates to true.

    • * If-Unmodified-Since condition evaluates to false.

      *

  • If both of the If-None-Match and * If-Modified-Since headers are present in the request as follows, * then Amazon S3 returns the HTTP status code 304 Not Modified:

    *

    • If-None-Match condition evaluates to * false.

    • If-Modified-Since condition * evaluates to true.

For more * information about conditional requests, see RFC 7232.

* Permissions

The permissions that you need to use this operation * depend on whether the bucket is versioned. If the bucket is versioned, you need * both the s3:GetObjectVersion and * s3:GetObjectVersionAttributes permissions for this operation. If * the bucket is not versioned, you need the s3:GetObject and * s3:GetObjectAttributes permissions. For more information, see Specifying * Permissions in a Policy in the Amazon S3 User Guide. If the object * that you request does not exist, the error Amazon S3 returns depends on whether * you also have the s3:ListBucket permission.

  • If you * have the s3:ListBucket permission on the bucket, Amazon S3 returns * an HTTP status code 404 Not Found ("no such key") error.

    • *

  • If you don't have the s3:ListBucket permission, Amazon S3 * returns an HTTP status code 403 Forbidden ("access denied") * error.

The following actions are related to * GetObjectAttributes:

See Also:

AWS * API Reference

*/ virtual Model::GetObjectAttributesOutcome GetObjectAttributes(const Model::GetObjectAttributesRequest& request) const; /** * A Callable wrapper for GetObjectAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetObjectAttributesOutcomeCallable GetObjectAttributesCallable(const GetObjectAttributesRequestT& request) const { return SubmitCallable(&S3Client::GetObjectAttributes, request); } /** * An Async wrapper for GetObjectAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetObjectAttributesAsync(const GetObjectAttributesRequestT& request, const GetObjectAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetObjectAttributes, request, handler, context); } /** *

Gets an object's current legal hold status. For more information, see Locking * Objects.

This action is not supported by Amazon S3 on Outposts.

*

The following action is related to GetObjectLegalHold:

See Also:

AWS * API Reference

*/ virtual Model::GetObjectLegalHoldOutcome GetObjectLegalHold(const Model::GetObjectLegalHoldRequest& request) const; /** * A Callable wrapper for GetObjectLegalHold that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetObjectLegalHoldOutcomeCallable GetObjectLegalHoldCallable(const GetObjectLegalHoldRequestT& request) const { return SubmitCallable(&S3Client::GetObjectLegalHold, request); } /** * An Async wrapper for GetObjectLegalHold that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetObjectLegalHoldAsync(const GetObjectLegalHoldRequestT& request, const GetObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetObjectLegalHold, request, handler, context); } /** *

Gets the Object Lock configuration for a bucket. The rule specified in the * Object Lock configuration will be applied by default to every new object placed * in the specified bucket. For more information, see Locking * Objects.

The following action is related to * GetObjectLockConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::GetObjectLockConfigurationOutcome GetObjectLockConfiguration(const Model::GetObjectLockConfigurationRequest& request) const; /** * A Callable wrapper for GetObjectLockConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetObjectLockConfigurationOutcomeCallable GetObjectLockConfigurationCallable(const GetObjectLockConfigurationRequestT& request) const { return SubmitCallable(&S3Client::GetObjectLockConfiguration, request); } /** * An Async wrapper for GetObjectLockConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetObjectLockConfigurationAsync(const GetObjectLockConfigurationRequestT& request, const GetObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetObjectLockConfiguration, request, handler, context); } /** *

Retrieves an object's retention settings. For more information, see Locking * Objects.

This action is not supported by Amazon S3 on Outposts.

*

The following action is related to GetObjectRetention:

See Also:

AWS * API Reference

*/ virtual Model::GetObjectRetentionOutcome GetObjectRetention(const Model::GetObjectRetentionRequest& request) const; /** * A Callable wrapper for GetObjectRetention that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetObjectRetentionOutcomeCallable GetObjectRetentionCallable(const GetObjectRetentionRequestT& request) const { return SubmitCallable(&S3Client::GetObjectRetention, request); } /** * An Async wrapper for GetObjectRetention that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetObjectRetentionAsync(const GetObjectRetentionRequestT& request, const GetObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetObjectRetention, request, handler, context); } /** *

Returns the tag-set of an object. You send the GET request against the * tagging subresource associated with the object.

To use this operation, * you must have permission to perform the s3:GetObjectTagging action. * By default, the GET action returns information about current version of an * object. For a versioned bucket, you can have multiple versions of an object in * your bucket. To retrieve tags of any other version, use the versionId query * parameter. You also need permission for the * s3:GetObjectVersionTagging action.

By default, the bucket * owner has this permission and can grant this permission to others.

For * information about the Amazon S3 object tagging feature, see Object * Tagging.

The following actions are related to * GetObjectTagging:

See Also:

AWS * API Reference

*/ virtual Model::GetObjectTaggingOutcome GetObjectTagging(const Model::GetObjectTaggingRequest& request) const; /** * A Callable wrapper for GetObjectTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetObjectTaggingOutcomeCallable GetObjectTaggingCallable(const GetObjectTaggingRequestT& request) const { return SubmitCallable(&S3Client::GetObjectTagging, request); } /** * An Async wrapper for GetObjectTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetObjectTaggingAsync(const GetObjectTaggingRequestT& request, const GetObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetObjectTagging, request, handler, context); } /** *

Returns torrent files from a bucket. BitTorrent can save you bandwidth when * you're distributing large files. For more information about BitTorrent, see Using * BitTorrent with Amazon S3.

You can get torrent only for * objects that are less than 5 GB in size, and that are not encrypted using * server-side encryption with a customer-provided encryption key.

*

To use GET, you must have READ access to the object.

This action is * not supported by Amazon S3 on Outposts.

The following action is related * to GetObjectTorrent:

See Also:

AWS * API Reference

*/ virtual Model::GetObjectTorrentOutcome GetObjectTorrent(const Model::GetObjectTorrentRequest& request) const; /** * A Callable wrapper for GetObjectTorrent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetObjectTorrentOutcomeCallable GetObjectTorrentCallable(const GetObjectTorrentRequestT& request) const { return SubmitCallable(&S3Client::GetObjectTorrent, request); } /** * An Async wrapper for GetObjectTorrent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetObjectTorrentAsync(const GetObjectTorrentRequestT& request, const GetObjectTorrentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetObjectTorrent, request, handler, context); } /** *

Retrieves the PublicAccessBlock configuration for an Amazon S3 * bucket. To use this operation, you must have the * s3:GetBucketPublicAccessBlock permission. For more information * about Amazon S3 permissions, see Specifying * Permissions in a Policy.

When Amazon S3 evaluates the * PublicAccessBlock configuration for a bucket or an object, it * checks the PublicAccessBlock configuration for both the bucket (or * the bucket that contains the object) and the bucket owner's account. If the * PublicAccessBlock settings are different between the bucket and the * account, Amazon S3 uses the most restrictive combination of the bucket-level and * account-level settings.

For more information about when * Amazon S3 considers a bucket or an object public, see The * Meaning of "Public".

The following operations are related to * GetPublicAccessBlock:

See Also:

AWS * API Reference

*/ virtual Model::GetPublicAccessBlockOutcome GetPublicAccessBlock(const Model::GetPublicAccessBlockRequest& request) const; /** * A Callable wrapper for GetPublicAccessBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPublicAccessBlockOutcomeCallable GetPublicAccessBlockCallable(const GetPublicAccessBlockRequestT& request) const { return SubmitCallable(&S3Client::GetPublicAccessBlock, request); } /** * An Async wrapper for GetPublicAccessBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPublicAccessBlockAsync(const GetPublicAccessBlockRequestT& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::GetPublicAccessBlock, request, handler, context); } /** *

This action is useful to determine if a bucket exists and you have permission * to access it. The action returns a 200 OK if the bucket exists and * you have permission to access it.

If the bucket does not exist or you do * not have permission to access it, the HEAD request returns a * generic 404 Not Found or 403 Forbidden code. A message * body is not included, so you cannot determine the exception beyond these error * codes.

To use this operation, you must have permissions to perform the * s3:ListBucket action. The 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.

To use this API * against an access point, you must provide the alias of the access point in place * of the bucket name or specify the access point ARN. When using the access point * ARN, you must direct requests to the access point hostname. The access point * hostname takes the form * AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using the * Amazon Web Services SDKs, you provide the ARN in place of the bucket name. For * more information see, Using * access points.

See Also:

AWS API * Reference

*/ virtual Model::HeadBucketOutcome HeadBucket(const Model::HeadBucketRequest& request) const; /** * A Callable wrapper for HeadBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::HeadBucketOutcomeCallable HeadBucketCallable(const HeadBucketRequestT& request) const { return SubmitCallable(&S3Client::HeadBucket, request); } /** * An Async wrapper for HeadBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void HeadBucketAsync(const HeadBucketRequestT& request, const HeadBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::HeadBucket, request, handler, context); } /** *

The HEAD action retrieves metadata from an object without returning the * object itself. This action is useful if you're only interested in an object's * metadata. To use HEAD, you must have READ access to the object.

A * HEAD request has the same options as a GET action on * an object. The response is identical to the GET response except * that there is no response body. Because of this, if the HEAD * request generates an error, it returns a generic 404 Not Found or * 403 Forbidden code. It is not possible to retrieve the exact * exception beyond these error codes.

If you encrypt an object by using * server-side encryption with customer-provided encryption keys (SSE-C) when you * store the object in Amazon S3, then when you retrieve the metadata from the * object, you must use the following headers:

  • *

    x-amz-server-side-encryption-customer-algorithm

  • *

    x-amz-server-side-encryption-customer-key

  • *

    x-amz-server-side-encryption-customer-key-MD5

For more * information about SSE-C, see Server-Side * Encryption (Using Customer-Provided Encryption Keys).

  • *

    Encryption request headers, like x-amz-server-side-encryption, * should not be sent for GET requests if your object uses server-side encryption * with KMS keys (SSE-KMS) or server-side encryption with Amazon S3–managed * encryption keys (SSE-S3). If your object does use these types of keys, you’ll * get an HTTP 400 BadRequest error.

  • The last modified property * in this case is the creation date of the object.

*

Request headers are limited to 8 KB in size. For more information, see Common * Request Headers.

Consider the following when using request * headers:

  • Consideration 1 – If both of the * If-Match and If-Unmodified-Since headers are present * in the request as follows:

    • If-Match condition * evaluates to true, and;

    • * If-Unmodified-Since condition evaluates to false;

      *

    Then Amazon S3 returns 200 OK and the data * requested.

  • Consideration 2 – If both of the * If-None-Match and If-Modified-Since headers are * present in the request as follows:

    • If-None-Match * condition evaluates to false, and;

    • * If-Modified-Since condition evaluates to true;

      *

    Then Amazon S3 returns the 304 Not Modified response * code.

For more information about conditional requests, see RFC 7232.

* Permissions

You need the relevant read object (or version) * permission for this operation. For more information, see Specifying * Permissions in a Policy. If the object you request does not exist, the error * Amazon S3 returns depends on whether you also have the s3:ListBucket * permission.

  • If you have the s3:ListBucket * permission on the bucket, Amazon S3 returns an HTTP status code 404 ("no such * key") error.

  • If you don’t have the s3:ListBucket * permission, Amazon S3 returns an HTTP status code 403 ("access denied") * error.

The following actions are related to * HeadObject:

See Also:

AWS API * Reference

*/ virtual Model::HeadObjectOutcome HeadObject(const Model::HeadObjectRequest& request) const; /** * A Callable wrapper for HeadObject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::HeadObjectOutcomeCallable HeadObjectCallable(const HeadObjectRequestT& request) const { return SubmitCallable(&S3Client::HeadObject, request); } /** * An Async wrapper for HeadObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void HeadObjectAsync(const HeadObjectRequestT& request, const HeadObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::HeadObject, request, handler, context); } /** *

Lists the analytics configurations for the bucket. You can have up to 1,000 * analytics configurations per bucket.

This action supports list pagination * and does not return more than 100 configurations at a time. You should always * check the IsTruncated element in the response. If there are no more * configurations to list, IsTruncated is set to false. If there are * more configurations to list, IsTruncated is set to true, and there * will be a value in NextContinuationToken. You use the * NextContinuationToken value to continue the pagination of the list * by passing the value in continuation-token in the request to GET * the next page.

To use this operation, you must have permissions to * perform the s3:GetAnalyticsConfiguration action. The 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.

For information about * Amazon S3 analytics feature, see Amazon * S3 Analytics – Storage Class Analysis.

The following operations are * related to ListBucketAnalyticsConfigurations:

See Also:

AWS * API Reference

*/ virtual Model::ListBucketAnalyticsConfigurationsOutcome ListBucketAnalyticsConfigurations(const Model::ListBucketAnalyticsConfigurationsRequest& request) const; /** * A Callable wrapper for ListBucketAnalyticsConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBucketAnalyticsConfigurationsOutcomeCallable ListBucketAnalyticsConfigurationsCallable(const ListBucketAnalyticsConfigurationsRequestT& request) const { return SubmitCallable(&S3Client::ListBucketAnalyticsConfigurations, request); } /** * An Async wrapper for ListBucketAnalyticsConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBucketAnalyticsConfigurationsAsync(const ListBucketAnalyticsConfigurationsRequestT& request, const ListBucketAnalyticsConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListBucketAnalyticsConfigurations, request, handler, context); } /** *

Lists the S3 Intelligent-Tiering configuration from the specified bucket.

*

The S3 Intelligent-Tiering storage class is designed to optimize storage * costs by automatically moving data to the most cost-effective storage access * tier, without performance impact or operational overhead. S3 Intelligent-Tiering * delivers automatic cost savings in three low latency and high throughput access * tiers. To get the lowest storage cost on data that can be accessed in minutes to * hours, you can choose to activate additional archiving capabilities.

The * S3 Intelligent-Tiering storage class is the ideal storage class for data with * unknown, changing, or unpredictable access patterns, independent of object size * or retention period. If the size of an object is less than 128 KB, it is not * monitored and not eligible for auto-tiering. Smaller objects can be stored, but * they are always charged at the Frequent Access tier rates in the S3 * Intelligent-Tiering storage class.

For more information, see Storage * class for automatically optimizing frequently and infrequently accessed * objects.

Operations related to * ListBucketIntelligentTieringConfigurations include:

See Also:

AWS * API Reference

*/ virtual Model::ListBucketIntelligentTieringConfigurationsOutcome ListBucketIntelligentTieringConfigurations(const Model::ListBucketIntelligentTieringConfigurationsRequest& request) const; /** * A Callable wrapper for ListBucketIntelligentTieringConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBucketIntelligentTieringConfigurationsOutcomeCallable ListBucketIntelligentTieringConfigurationsCallable(const ListBucketIntelligentTieringConfigurationsRequestT& request) const { return SubmitCallable(&S3Client::ListBucketIntelligentTieringConfigurations, request); } /** * An Async wrapper for ListBucketIntelligentTieringConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBucketIntelligentTieringConfigurationsAsync(const ListBucketIntelligentTieringConfigurationsRequestT& request, const ListBucketIntelligentTieringConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListBucketIntelligentTieringConfigurations, request, handler, context); } /** *

Returns a list of inventory configurations for the bucket. You can have up to * 1,000 analytics configurations per bucket.

This action supports list * pagination and does not return more than 100 configurations at a time. Always * check the IsTruncated element in the response. If there are no more * configurations to list, IsTruncated is set to false. If there are * more configurations to list, IsTruncated is set to true, and there * is a value in NextContinuationToken. You use the * NextContinuationToken value to continue the pagination of the list * by passing the value in continuation-token in the request to GET * the next page.

To use this operation, you must have permissions to * perform the s3:GetInventoryConfiguration action. The 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.

For information about * the Amazon S3 inventory feature, see Amazon * S3 Inventory

The following operations are related to * ListBucketInventoryConfigurations:

See Also:

AWS * API Reference

*/ virtual Model::ListBucketInventoryConfigurationsOutcome ListBucketInventoryConfigurations(const Model::ListBucketInventoryConfigurationsRequest& request) const; /** * A Callable wrapper for ListBucketInventoryConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBucketInventoryConfigurationsOutcomeCallable ListBucketInventoryConfigurationsCallable(const ListBucketInventoryConfigurationsRequestT& request) const { return SubmitCallable(&S3Client::ListBucketInventoryConfigurations, request); } /** * An Async wrapper for ListBucketInventoryConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBucketInventoryConfigurationsAsync(const ListBucketInventoryConfigurationsRequestT& request, const ListBucketInventoryConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListBucketInventoryConfigurations, request, handler, context); } /** *

Lists the metrics configurations for the bucket. The metrics configurations * are only for the request metrics of the bucket and do not provide information on * daily storage metrics. You can have up to 1,000 configurations per bucket.

*

This action supports list pagination and does not return more than 100 * configurations at a time. Always check the IsTruncated element in * the response. If there are no more configurations to list, * IsTruncated is set to false. If there are more configurations to * list, IsTruncated is set to true, and there is a value in * NextContinuationToken. You use the * NextContinuationToken value to continue the pagination of the list * by passing the value in continuation-token in the request to * GET the next page.

To use this operation, you must have * permissions to perform the s3:GetMetricsConfiguration action. The * 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.

For more information * about metrics configurations and CloudWatch request metrics, see Monitoring * Metrics with Amazon CloudWatch.

The following operations are related * to ListBucketMetricsConfigurations:

See Also:

AWS * API Reference

*/ virtual Model::ListBucketMetricsConfigurationsOutcome ListBucketMetricsConfigurations(const Model::ListBucketMetricsConfigurationsRequest& request) const; /** * A Callable wrapper for ListBucketMetricsConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBucketMetricsConfigurationsOutcomeCallable ListBucketMetricsConfigurationsCallable(const ListBucketMetricsConfigurationsRequestT& request) const { return SubmitCallable(&S3Client::ListBucketMetricsConfigurations, request); } /** * An Async wrapper for ListBucketMetricsConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBucketMetricsConfigurationsAsync(const ListBucketMetricsConfigurationsRequestT& request, const ListBucketMetricsConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListBucketMetricsConfigurations, request, handler, context); } /** *

Returns a list of all buckets owned by the authenticated sender of the * request. To use this operation, you must have the * s3:ListAllMyBuckets permission.

See Also:

AWS API * Reference

*/ virtual Model::ListBucketsOutcome ListBuckets() const; /** * A Callable wrapper for ListBuckets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBucketsOutcomeCallable ListBucketsCallable() const { return SubmitCallable(&S3Client::ListBuckets); } /** * An Async wrapper for ListBuckets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBucketsAsync(const ListBucketsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListBuckets, handler, context); } /** *

This action lists in-progress multipart uploads. An in-progress multipart * upload is a multipart upload that has been initiated using the Initiate * Multipart Upload request, but has not yet been completed or aborted.

This * action returns at most 1,000 multipart uploads in the response. 1,000 multipart * uploads is the maximum number of uploads a response can include, which is also * the default value. You can further limit the number of uploads in a response by * specifying the max-uploads parameter in the response. If additional * multipart uploads satisfy the list criteria, the response will contain an * IsTruncated element with the value true. To list the additional * multipart uploads, use the key-marker and * upload-id-marker request parameters.

In the response, the * uploads are sorted by key. If your application has initiated more than one * multipart upload using the same object key, then uploads in the response are * first sorted by key. Additionally, uploads are sorted in ascending order within * each key by the upload initiation time.

For more information on multipart * uploads, see Uploading * Objects Using Multipart Upload.

For information on permissions * required to use the multipart upload API, see Multipart * Upload and Permissions.

The following operations are related to * ListMultipartUploads:

See Also:

AWS * API Reference

*/ virtual Model::ListMultipartUploadsOutcome ListMultipartUploads(const Model::ListMultipartUploadsRequest& request) const; /** * A Callable wrapper for ListMultipartUploads that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMultipartUploadsOutcomeCallable ListMultipartUploadsCallable(const ListMultipartUploadsRequestT& request) const { return SubmitCallable(&S3Client::ListMultipartUploads, request); } /** * An Async wrapper for ListMultipartUploads that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMultipartUploadsAsync(const ListMultipartUploadsRequestT& request, const ListMultipartUploadsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListMultipartUploads, request, handler, context); } /** *

Returns metadata about all versions of the objects in a bucket. You can also * use request parameters as selection criteria to return metadata about a subset * of all the object versions.

To use this operation, you must * have permissions to perform the s3:ListBucketVersions action. Be * aware of the name difference.

A 200 OK response can * contain valid or invalid XML. Make sure to design your application to parse the * contents of the response and handle it appropriately.

To use this * operation, you must have READ access to the bucket.

This action is not * supported by Amazon S3 on Outposts.

The following operations are related * to ListObjectVersions:

See Also:

AWS * API Reference

*/ virtual Model::ListObjectVersionsOutcome ListObjectVersions(const Model::ListObjectVersionsRequest& request) const; /** * A Callable wrapper for ListObjectVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListObjectVersionsOutcomeCallable ListObjectVersionsCallable(const ListObjectVersionsRequestT& request) const { return SubmitCallable(&S3Client::ListObjectVersions, request); } /** * An Async wrapper for ListObjectVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListObjectVersionsAsync(const ListObjectVersionsRequestT& request, const ListObjectVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListObjectVersions, request, handler, context); } /** *

Returns some or all (up to 1,000) of the objects in a bucket. You can use the * request parameters as selection criteria to return a subset of the objects in a * bucket. A 200 OK response can contain valid or invalid XML. Be sure to design * your application to parse the contents of the response and handle it * appropriately.

This action has been revised. We recommend * that you use the newer version, ListObjectsV2, * when developing applications. For backward compatibility, Amazon S3 continues to * support ListObjects.

The following operations * are related to ListObjects:

See Also:

AWS API * Reference

*/ virtual Model::ListObjectsOutcome ListObjects(const Model::ListObjectsRequest& request) const; /** * A Callable wrapper for ListObjects that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListObjectsOutcomeCallable ListObjectsCallable(const ListObjectsRequestT& request) const { return SubmitCallable(&S3Client::ListObjects, request); } /** * An Async wrapper for ListObjects that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListObjectsAsync(const ListObjectsRequestT& request, const ListObjectsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListObjects, request, handler, context); } /** *

Returns some or all (up to 1,000) of the objects in a bucket with each * request. You can use the request parameters as selection criteria to return a * subset of the objects in a bucket. A 200 OK response can contain * valid or invalid XML. Make sure to design your application to parse the contents * of the response and handle it appropriately. Objects are returned sorted in an * ascending order of the respective key names in the list. For more information * about listing objects, see Listing * object keys programmatically

To use this operation, you must have * READ access to the bucket.

To use this action in an Identity and Access * Management (IAM) policy, you must have permissions to perform the * s3:ListBucket action. The 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.

This * section describes the latest revision of this action. We recommend that you use * this revised API for application development. For backward compatibility, Amazon * S3 continues to support the prior version of this API, ListObjects.

*

To get a list of your buckets, see ListBuckets.

*

The following operations are related to ListObjectsV2:

See Also:

AWS * API Reference

*/ virtual Model::ListObjectsV2Outcome ListObjectsV2(const Model::ListObjectsV2Request& request) const; /** * A Callable wrapper for ListObjectsV2 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListObjectsV2OutcomeCallable ListObjectsV2Callable(const ListObjectsV2RequestT& request) const { return SubmitCallable(&S3Client::ListObjectsV2, request); } /** * An Async wrapper for ListObjectsV2 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListObjectsV2Async(const ListObjectsV2RequestT& request, const ListObjectsV2ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListObjectsV2, request, handler, context); } /** *

Lists the parts that have been uploaded for a specific multipart upload. This * operation must include the upload ID, which you obtain by sending the initiate * multipart upload request (see CreateMultipartUpload). * This request returns a maximum of 1,000 uploaded parts. The default number of * parts returned is 1,000 parts. You can restrict the number of parts returned by * specifying the max-parts request parameter. If your multipart * upload consists of more than 1,000 parts, the response returns an * IsTruncated field with the value of true, and a * NextPartNumberMarker element. In subsequent ListParts * requests you can include the part-number-marker query string parameter and set * its value to the NextPartNumberMarker field value from the previous * response.

If the upload was created using a checksum algorithm, you will * need to have permission to the kms:Decrypt action for the request * to succeed.

For more information on multipart uploads, see Uploading * Objects Using Multipart Upload.

For information on permissions * required to use the multipart upload API, see Multipart * Upload and Permissions.

The following operations are related to * ListParts:

See Also:

AWS API * Reference

*/ virtual Model::ListPartsOutcome ListParts(const Model::ListPartsRequest& request) const; /** * A Callable wrapper for ListParts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPartsOutcomeCallable ListPartsCallable(const ListPartsRequestT& request) const { return SubmitCallable(&S3Client::ListParts, request); } /** * An Async wrapper for ListParts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPartsAsync(const ListPartsRequestT& request, const ListPartsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::ListParts, request, handler, context); } /** *

Sets the accelerate configuration of an existing bucket. Amazon S3 Transfer * Acceleration is a bucket-level feature that enables you to perform faster data * transfers to Amazon S3.

To use this operation, you must have permission * to perform the s3:PutAccelerateConfiguration action. The 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.

The Transfer * Acceleration state of a bucket can be set to one of the following two * values:

  • Enabled – Enables accelerated data transfers to the * bucket.

  • Suspended – Disables accelerated data transfers to * the bucket.

The GetBucketAccelerateConfiguration * action returns the transfer acceleration state of a bucket.

After setting * the Transfer Acceleration state of a bucket to Enabled, it might take up to * thirty minutes before the data transfer rates to the bucket increase.

* The name of the bucket used for Transfer Acceleration must be DNS-compliant and * must not contain periods (".").

For more information about transfer * acceleration, see Transfer * Acceleration.

The following operations are related to * PutBucketAccelerateConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketAccelerateConfigurationOutcome PutBucketAccelerateConfiguration(const Model::PutBucketAccelerateConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketAccelerateConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketAccelerateConfigurationOutcomeCallable PutBucketAccelerateConfigurationCallable(const PutBucketAccelerateConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketAccelerateConfiguration, request); } /** * An Async wrapper for PutBucketAccelerateConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketAccelerateConfigurationAsync(const PutBucketAccelerateConfigurationRequestT& request, const PutBucketAccelerateConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketAccelerateConfiguration, request, handler, context); } /** *

Sets the permissions on an existing bucket using access control lists (ACL). * For more information, see Using * ACLs. To set the ACL of a bucket, you must have WRITE_ACP * permission.

You can use one of the following two ways to set a bucket's * permissions:

  • Specify the ACL in the request body

  • *

    Specify permissions using request headers

You * cannot specify access permission using both the body and the request * headers.

Depending on your application needs, you may choose to * set the ACL on a bucket using either the request body or the headers. For * example, if you have an existing application that updates a bucket ACL using the * request body, then you can continue to use that approach.

If * your bucket uses the bucket owner enforced setting for S3 Object Ownership, ACLs * are disabled and no longer affect permissions. You must use policies to grant * access to your bucket and the objects in it. Requests to set ACLs or update ACLs * fail and return the AccessControlListNotSupported error code. * Requests to read ACLs are still supported. For more information, see Controlling * object ownership in the Amazon S3 User Guide.

* Access Permissions

You can set access permissions using one of * the following methods:

  • Specify a canned ACL with the * x-amz-acl request header. Amazon S3 supports a set of predefined * ACLs, known as canned ACLs. Each canned ACL has a predefined set of * grantees and permissions. Specify the canned ACL name as the value of * x-amz-acl. If you use this header, you cannot use other access * control-specific headers in your request. For more information, see Canned * ACL.

  • Specify access permissions explicitly with the * x-amz-grant-read, x-amz-grant-read-acp, * x-amz-grant-write-acp, and x-amz-grant-full-control * headers. When using these headers, you specify explicit access permissions and * grantees (Amazon Web Services accounts or Amazon S3 groups) who will receive the * permission. If you use these ACL-specific headers, you cannot use the * x-amz-acl header to set a canned ACL. These parameters map to the * set of permissions that Amazon S3 supports in an ACL. For more information, see * Access * Control List (ACL) Overview.

    You specify each grantee as a type=value * pair, where the type is one of the following:

    • id * – if the value specified is the canonical user ID of an Amazon Web Services * account

    • uri – if you are granting permissions to * a predefined group

    • emailAddress – if the value * specified is the email address of an Amazon Web Services account

      *

      Using email addresses to specify a grantee is only supported in the following * Amazon Web Services Regions:

      • US East (N. Virginia)

        • *

      • US West (N. California)

      • US West (Oregon)

        • *

      • Asia Pacific (Singapore)

      • Asia Pacific (Sydney)

        *

      • Asia Pacific (Tokyo)

      • Europe (Ireland)

        • *

      • South America (São Paulo)

      For a list of all the * Amazon S3 supported Regions and endpoints, see Regions * and Endpoints in the Amazon Web Services General Reference.

      *

    For example, the following x-amz-grant-write header * grants create, overwrite, and delete objects permission to LogDelivery group * predefined by Amazon S3 and two Amazon Web Services accounts identified by their * email addresses.

    x-amz-grant-write: * uri="http://acs.amazonaws.com/groups/s3/LogDelivery", id="111122223333", * id="555566667777"

You can use either a canned ACL or * specify access permissions explicitly. You cannot do both.

Grantee * Values

You can specify the person (grantee) to whom you're assigning * access rights (using request elements) in the following ways:

  • *

    By the person's ID:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="CanonicalUser"><ID><>ID<></ID><DisplayName><>GranteesEmail<></DisplayName> * </Grantee>

    DisplayName is optional and ignored in the * request

  • By URI:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="Group"><URI><>http://acs.amazonaws.com/groups/global/AuthenticatedUsers<></URI></Grantee> *

  • By Email address:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="AmazonCustomerByEmail"><EmailAddress><>Grantees@email.com<></EmailAddress>lt;/Grantee> *

    The grantee is resolved to the CanonicalUser and, in a response to a GET * Object acl request, appears as the CanonicalUser.

    Using email * addresses to specify a grantee is only supported in the following Amazon Web * Services Regions:

    • US East (N. Virginia)

    • US * West (N. California)

    • US West (Oregon)

    • Asia * Pacific (Singapore)

    • Asia Pacific (Sydney)

    • *

      Asia Pacific (Tokyo)

    • Europe (Ireland)

    • *

      South America (São Paulo)

    For a list of all the Amazon S3 * supported Regions and endpoints, see Regions * and Endpoints in the Amazon Web Services General Reference.

    *

Related Resources

See Also:

AWS API * Reference

*/ virtual Model::PutBucketAclOutcome PutBucketAcl(const Model::PutBucketAclRequest& request) const; /** * A Callable wrapper for PutBucketAcl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketAclOutcomeCallable PutBucketAclCallable(const PutBucketAclRequestT& request) const { return SubmitCallable(&S3Client::PutBucketAcl, request); } /** * An Async wrapper for PutBucketAcl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketAclAsync(const PutBucketAclRequestT& request, const PutBucketAclResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketAcl, request, handler, context); } /** *

Sets an analytics configuration for the bucket (specified by the analytics * configuration ID). You can have up to 1,000 analytics configurations per * bucket.

You can choose to have storage class analysis export analysis * reports sent to a comma-separated values (CSV) flat file. See the * DataExport request element. Reports are updated daily and are based * on the object filters that you configure. When selecting data export, you * specify a destination bucket and an optional destination prefix where the file * is written. You can export the data to a destination bucket in a different * account. However, the destination bucket must be in the same Region as the * bucket that you are making the PUT analytics configuration to. For more * information, see Amazon * S3 Analytics – Storage Class Analysis.

You must create a * bucket policy on the destination bucket where the exported file is written to * grant permissions to Amazon S3 to write objects to the bucket. For an example * policy, see Granting * Permissions for Amazon S3 Inventory and Storage Class Analysis.

*

To use this operation, you must have permissions to perform the * s3:PutAnalyticsConfiguration action. The 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.

* Special Errors

    • HTTP Error: HTTP 400 Bad * Request

    • Code: InvalidArgument

    • * Cause: Invalid argument.

    • * HTTP Error: HTTP 400 Bad Request

    • Code: * TooManyConfigurations

    • Cause: You are attempting to * create a new configuration but have already reached the 1,000-configuration * limit.

    • HTTP Error: HTTP 403 * Forbidden

    • Code: AccessDenied

    • * Cause: You are not the owner of the specified bucket, or you do not have the * s3:PutAnalyticsConfiguration bucket permission to set the configuration on the * bucket.

Related * Resources

See Also:

AWS * API Reference

*/ virtual Model::PutBucketAnalyticsConfigurationOutcome PutBucketAnalyticsConfiguration(const Model::PutBucketAnalyticsConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketAnalyticsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketAnalyticsConfigurationOutcomeCallable PutBucketAnalyticsConfigurationCallable(const PutBucketAnalyticsConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketAnalyticsConfiguration, request); } /** * An Async wrapper for PutBucketAnalyticsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketAnalyticsConfigurationAsync(const PutBucketAnalyticsConfigurationRequestT& request, const PutBucketAnalyticsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketAnalyticsConfiguration, request, handler, context); } /** *

Sets the cors configuration for your bucket. If the * configuration exists, Amazon S3 replaces it.

To use this operation, you * must be allowed to perform the s3:PutBucketCORS action. By default, * the bucket owner has this permission and can grant it to others.

You set * this configuration on a bucket so that the bucket can service cross-origin * requests. For example, you might want to enable a request whose origin is * http://www.example.com to access your Amazon S3 bucket at * my.example.bucket.com by using the browser's * XMLHttpRequest capability.

To enable cross-origin resource * sharing (CORS) on a bucket, you add the cors subresource to the * bucket. The cors subresource is an XML document in which you * configure rules that identify origins and the HTTP methods that can be executed * on your bucket. The document is limited to 64 KB in size.

When Amazon S3 * receives a cross-origin request (or a pre-flight OPTIONS request) against a * bucket, it evaluates the cors configuration on the bucket and uses * the first CORSRule rule that matches the incoming browser request * to enable a cross-origin request. For a rule to match, the following conditions * must be met:

  • The request's Origin header must * match AllowedOrigin elements.

  • The request method * (for example, GET, PUT, HEAD, and so on) or the * Access-Control-Request-Method header in case of a pre-flight * OPTIONS request must be one of the AllowedMethod * elements.

  • Every header specified in the * Access-Control-Request-Headers request header of a pre-flight * request must match an AllowedHeader element.

* For more information about CORS, go to Enabling * Cross-Origin Resource Sharing in the Amazon S3 User Guide.

Related Resources

See Also:

AWS * API Reference

*/ virtual Model::PutBucketCorsOutcome PutBucketCors(const Model::PutBucketCorsRequest& request) const; /** * A Callable wrapper for PutBucketCors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketCorsOutcomeCallable PutBucketCorsCallable(const PutBucketCorsRequestT& request) const { return SubmitCallable(&S3Client::PutBucketCors, request); } /** * An Async wrapper for PutBucketCors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketCorsAsync(const PutBucketCorsRequestT& request, const PutBucketCorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketCors, request, handler, context); } /** *

This action uses the encryption subresource to configure default * encryption and Amazon S3 Bucket Key for an existing bucket.

Default * encryption for a bucket can use server-side encryption with Amazon S3-managed * keys (SSE-S3) or customer managed keys (SSE-KMS). If you specify default * encryption using SSE-KMS, you can also configure Amazon S3 Bucket Key. When the * default encryption is SSE-KMS, if you upload an object to the bucket and do not * specify the KMS key to use for encryption, Amazon S3 uses the default Amazon Web * Services managed KMS key for your account. For information about default * encryption, see Amazon * S3 default bucket encryption in the Amazon S3 User Guide. For more * information about S3 Bucket Keys, see Amazon S3 * Bucket Keys in the Amazon S3 User Guide.

This * action requires Amazon Web Services Signature Version 4. For more information, * see * Authenticating Requests (Amazon Web Services Signature Version 4).

*

To use this operation, you must have permissions to perform the * s3:PutEncryptionConfiguration action. The 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 in the Amazon S3 User Guide. *

Related Resources

See Also:

AWS * API Reference

*/ virtual Model::PutBucketEncryptionOutcome PutBucketEncryption(const Model::PutBucketEncryptionRequest& request) const; /** * A Callable wrapper for PutBucketEncryption that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketEncryptionOutcomeCallable PutBucketEncryptionCallable(const PutBucketEncryptionRequestT& request) const { return SubmitCallable(&S3Client::PutBucketEncryption, request); } /** * An Async wrapper for PutBucketEncryption that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketEncryptionAsync(const PutBucketEncryptionRequestT& request, const PutBucketEncryptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketEncryption, request, handler, context); } /** *

Puts a S3 Intelligent-Tiering configuration to the specified bucket. You can * have up to 1,000 S3 Intelligent-Tiering configurations per bucket.

The S3 * Intelligent-Tiering storage class is designed to optimize storage costs by * automatically moving data to the most cost-effective storage access tier, * without performance impact or operational overhead. S3 Intelligent-Tiering * delivers automatic cost savings in three low latency and high throughput access * tiers. To get the lowest storage cost on data that can be accessed in minutes to * hours, you can choose to activate additional archiving capabilities.

The * S3 Intelligent-Tiering storage class is the ideal storage class for data with * unknown, changing, or unpredictable access patterns, independent of object size * or retention period. If the size of an object is less than 128 KB, it is not * monitored and not eligible for auto-tiering. Smaller objects can be stored, but * they are always charged at the Frequent Access tier rates in the S3 * Intelligent-Tiering storage class.

For more information, see Storage * class for automatically optimizing frequently and infrequently accessed * objects.

Operations related to * PutBucketIntelligentTieringConfiguration include:

You only need S3 Intelligent-Tiering enabled on a * bucket if you want to automatically move objects stored in the S3 * Intelligent-Tiering storage class to the Archive Access or Deep Archive Access * tier.

Special Errors

  • HTTP 400 Bad Request Error

    • Code: * InvalidArgument

    • Cause: Invalid Argument

      • *

  • HTTP 400 Bad Request Error

      *

    • Code: TooManyConfigurations

    • Cause: You * are attempting to create a new configuration but have already reached the * 1,000-configuration limit.

  • HTTP * 403 Forbidden Error

    • Code: AccessDenied

      • *

    • Cause: You are not the owner of the specified bucket, or you do * not have the s3:PutIntelligentTieringConfiguration bucket * permission to set the configuration on the bucket.

    • *

See Also:

AWS * API Reference

*/ virtual Model::PutBucketIntelligentTieringConfigurationOutcome PutBucketIntelligentTieringConfiguration(const Model::PutBucketIntelligentTieringConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketIntelligentTieringConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketIntelligentTieringConfigurationOutcomeCallable PutBucketIntelligentTieringConfigurationCallable(const PutBucketIntelligentTieringConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketIntelligentTieringConfiguration, request); } /** * An Async wrapper for PutBucketIntelligentTieringConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketIntelligentTieringConfigurationAsync(const PutBucketIntelligentTieringConfigurationRequestT& request, const PutBucketIntelligentTieringConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketIntelligentTieringConfiguration, request, handler, context); } /** *

This implementation of the PUT action adds an inventory * configuration (identified by the inventory ID) to the bucket. You can have up to * 1,000 inventory configurations per bucket.

Amazon S3 inventory generates * inventories of the objects in the bucket on a daily or weekly basis, and the * results are published to a flat file. The bucket that is inventoried is called * the source bucket, and the bucket where the inventory flat file is stored * is called the destination bucket. The destination bucket must be * in the same Amazon Web Services Region as the source bucket.

When * you configure an inventory for a source bucket, you specify the * destination bucket where you want the inventory to be stored, and whether * to generate the inventory daily or weekly. You can also configure what object * metadata to include and whether to inventory all object versions or only current * versions. For more information, see Amazon * S3 Inventory in the Amazon S3 User Guide.

You must create * a bucket policy on the destination bucket to grant permissions to Amazon * S3 to write objects to the bucket in the defined location. For an example * policy, see * Granting Permissions for Amazon S3 Inventory and Storage Class Analysis.

*

To use this operation, you must have permissions to perform the * s3:PutInventoryConfiguration action. The 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 in the Amazon S3 User * Guide.

Special Errors

  • HTTP 400 Bad Request Error

    • Code: * InvalidArgument

    • Cause: Invalid Argument

      • *

  • HTTP 400 Bad Request Error

      *

    • Code: TooManyConfigurations

    • Cause: You * are attempting to create a new configuration but have already reached the * 1,000-configuration limit.

  • HTTP * 403 Forbidden Error

    • Code: AccessDenied

      • *

    • Cause: You are not the owner of the specified bucket, or you do * not have the s3:PutInventoryConfiguration bucket permission to set * the configuration on the bucket.

* Related Resources

See Also:

AWS * API Reference

*/ virtual Model::PutBucketInventoryConfigurationOutcome PutBucketInventoryConfiguration(const Model::PutBucketInventoryConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketInventoryConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketInventoryConfigurationOutcomeCallable PutBucketInventoryConfigurationCallable(const PutBucketInventoryConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketInventoryConfiguration, request); } /** * An Async wrapper for PutBucketInventoryConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketInventoryConfigurationAsync(const PutBucketInventoryConfigurationRequestT& request, const PutBucketInventoryConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketInventoryConfiguration, request, handler, context); } /** *

Creates a new lifecycle configuration for the bucket or replaces an existing * lifecycle configuration. Keep in mind that this will overwrite an existing * lifecycle configuration, so if you want to retain any configuration details, * they must be included in the new lifecycle configuration. For information about * lifecycle configuration, see Managing * your storage lifecycle.

Bucket lifecycle configuration now * supports specifying a lifecycle rule using an object key name prefix, one or * more object tags, or a combination of both. Accordingly, this section describes * the latest API. The previous version of the API supported filtering based only * on an object key name prefix, which is supported for backward compatibility. For * the related API description, see PutBucketLifecycle.

*

Rules

You specify the lifecycle configuration in your * request body. The lifecycle configuration is specified as XML consisting of one * or more rules. An Amazon S3 Lifecycle configuration can have up to 1,000 rules. * This limit is not adjustable. Each rule consists of the following:

  • *

    Filter identifying a subset of objects to which the rule applies. The filter * can be based on a key name prefix, object tags, or a combination of both.

    *

  • Status whether the rule is in effect.

  • One or * more lifecycle transition and expiration actions that you want Amazon S3 to * perform on the objects identified by the filter. If the state of your bucket is * versioning-enabled or versioning-suspended, you can have many versions of the * same object (one current version and zero or more noncurrent versions). Amazon * S3 provides predefined actions that you can specify for current and noncurrent * object versions.

For more information, see Object * Lifecycle Management and Lifecycle * Configuration Elements.

Permissions

By default, all * Amazon S3 resources are private, including buckets, objects, and related * subresources (for example, lifecycle configuration and website configuration). * Only the resource owner (that is, the Amazon Web Services account that created * it) can access the resource. The resource owner can optionally grant access * permissions to others by writing an access policy. For this operation, a user * must get the s3:PutLifecycleConfiguration permission.

You * can also explicitly deny permissions. Explicit deny also supersedes any other * permissions. If you want to block users or accounts from removing or deleting * objects from your bucket, you must deny them permissions for the following * actions:

  • s3:DeleteObject

  • * s3:DeleteObjectVersion

  • * s3:PutLifecycleConfiguration

For more * information about permissions, see Managing * Access Permissions to Your Amazon S3 Resources.

The following are * related to PutBucketLifecycleConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketLifecycleConfigurationOutcome PutBucketLifecycleConfiguration(const Model::PutBucketLifecycleConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketLifecycleConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketLifecycleConfigurationOutcomeCallable PutBucketLifecycleConfigurationCallable(const PutBucketLifecycleConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketLifecycleConfiguration, request); } /** * An Async wrapper for PutBucketLifecycleConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketLifecycleConfigurationAsync(const PutBucketLifecycleConfigurationRequestT& request, const PutBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketLifecycleConfiguration, request, handler, context); } /** *

Set the logging parameters for a bucket and to specify permissions for who * can view and modify the logging parameters. All logs are saved to buckets in the * same Amazon Web Services Region as the source bucket. To set the logging status * of a bucket, you must be the bucket owner.

The bucket owner is * automatically granted FULL_CONTROL to all logs. You use the Grantee * request element to grant access to other people. The Permissions * request element specifies the kind of access the grantee has to the logs.

*

If the target bucket for log delivery uses the bucket owner * enforced setting for S3 Object Ownership, you can't use the Grantee * request element to grant access to others. Permissions can only be granted using * policies. For more information, see Permissions * for server access log delivery in the Amazon S3 User Guide.

*

Grantee Values

You can specify the person * (grantee) to whom you're assigning access rights (using request elements) in the * following ways:

  • By the person's ID:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="CanonicalUser"><ID><>ID<></ID><DisplayName><>GranteesEmail<></DisplayName> * </Grantee>

    DisplayName is optional and ignored in the * request.

  • By Email address:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="AmazonCustomerByEmail"><EmailAddress><>Grantees@email.com<></EmailAddress></Grantee> *

    The grantee is resolved to the CanonicalUser and, in a response to a GET * Object acl request, appears as the CanonicalUser.

  • By URI:

    *

    <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="Group"><URI><>http://acs.amazonaws.com/groups/global/AuthenticatedUsers<></URI></Grantee> *

To enable logging, you use LoggingEnabled and its children * request elements. To disable logging, you use an empty BucketLoggingStatus * request element:

<BucketLoggingStatus * xmlns="http://doc.s3.amazonaws.com/2006-03-01" />

For more * information about server access logging, see Server * Access Logging in the Amazon S3 User Guide.

For more * information about creating a bucket, see CreateBucket. * For more information about returning the logging status of a bucket, see GetBucketLogging.

*

The following operations are related to PutBucketLogging:

*

See Also:

AWS * API Reference

*/ virtual Model::PutBucketLoggingOutcome PutBucketLogging(const Model::PutBucketLoggingRequest& request) const; /** * A Callable wrapper for PutBucketLogging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketLoggingOutcomeCallable PutBucketLoggingCallable(const PutBucketLoggingRequestT& request) const { return SubmitCallable(&S3Client::PutBucketLogging, request); } /** * An Async wrapper for PutBucketLogging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketLoggingAsync(const PutBucketLoggingRequestT& request, const PutBucketLoggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketLogging, request, handler, context); } /** *

Sets a metrics configuration (specified by the metrics configuration ID) for * the bucket. You can have up to 1,000 metrics configurations per bucket. If * you're updating an existing metrics configuration, note that this is a full * replacement of the existing metrics configuration. If you don't include the * elements you want to keep, they are erased.

To use this operation, you * must have permissions to perform the s3:PutMetricsConfiguration * action. The 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.

For information about * CloudWatch request metrics for Amazon S3, see Monitoring * Metrics with Amazon CloudWatch.

The following operations are related * to PutBucketMetricsConfiguration:

GetBucketLifecycle has the following special * error:

  • Error code: TooManyConfigurations

      *

    • Description: You are attempting to create a new configuration but have * already reached the 1,000-configuration limit.

    • HTTP Status * Code: HTTP 400 Bad Request

See Also:

AWS * API Reference

*/ virtual Model::PutBucketMetricsConfigurationOutcome PutBucketMetricsConfiguration(const Model::PutBucketMetricsConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketMetricsConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketMetricsConfigurationOutcomeCallable PutBucketMetricsConfigurationCallable(const PutBucketMetricsConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketMetricsConfiguration, request); } /** * An Async wrapper for PutBucketMetricsConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketMetricsConfigurationAsync(const PutBucketMetricsConfigurationRequestT& request, const PutBucketMetricsConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketMetricsConfiguration, request, handler, context); } /** *

Enables notifications of specified events for a bucket. For more information * about event notifications, see Configuring * Event Notifications.

Using this API, you can replace an existing * notification configuration. The configuration is an XML file that defines the * event types that you want Amazon S3 to publish and the destination where you * want Amazon S3 to publish an event notification when it detects an event of the * specified type.

By default, your bucket has no event notifications * configured. That is, the notification configuration will be an empty * NotificationConfiguration.

* <NotificationConfiguration>

* </NotificationConfiguration>

This action replaces the * existing notification configuration with the configuration you include in the * request body.

After Amazon S3 receives this request, it first verifies * that any Amazon Simple Notification Service (Amazon SNS) or Amazon Simple Queue * Service (Amazon SQS) destination exists, and that the bucket owner has * permission to publish to it by sending a test notification. In the case of * Lambda destinations, Amazon S3 verifies that the Lambda function permissions * grant Amazon S3 permission to invoke the function from the Amazon S3 bucket. For * more information, see Configuring * Notifications for Amazon S3 Events.

You can disable notifications by * adding the empty NotificationConfiguration element.

For more information * about the number of event notification configurations that you can create per * bucket, see Amazon S3 * service quotas in Amazon Web Services General Reference.

By * default, only the bucket owner can configure notifications on a bucket. However, * bucket owners can use a bucket policy to grant permission to other users to set * this configuration with s3:PutBucketNotification permission.

*

The PUT notification is an atomic operation. For example, suppose your * notification configuration includes SNS topic, SQS queue, and Lambda function * configurations. When you send a PUT request with this configuration, Amazon S3 * sends test messages to your SNS topic. If the message fails, the entire PUT * action will fail, and Amazon S3 will not add the configuration to your * bucket.

Responses

If the configuration in the * request body includes only one TopicConfiguration specifying only * the s3:ReducedRedundancyLostObject event type, the response will * also include the x-amz-sns-test-message-id header containing the * message ID of the test notification sent to the topic.

The following * action is related to PutBucketNotificationConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketNotificationConfigurationOutcome PutBucketNotificationConfiguration(const Model::PutBucketNotificationConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketNotificationConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketNotificationConfigurationOutcomeCallable PutBucketNotificationConfigurationCallable(const PutBucketNotificationConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketNotificationConfiguration, request); } /** * An Async wrapper for PutBucketNotificationConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketNotificationConfigurationAsync(const PutBucketNotificationConfigurationRequestT& request, const PutBucketNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketNotificationConfiguration, request, handler, context); } /** *

Creates or modifies OwnershipControls for an Amazon S3 bucket. * To use this operation, you must have the * s3:PutBucketOwnershipControls permission. For more information * about Amazon S3 permissions, see Specifying * permissions in a policy.

For information about Amazon S3 Object * Ownership, see Using * object ownership.

The following operations are related to * PutBucketOwnershipControls:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketOwnershipControlsOutcome PutBucketOwnershipControls(const Model::PutBucketOwnershipControlsRequest& request) const; /** * A Callable wrapper for PutBucketOwnershipControls that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketOwnershipControlsOutcomeCallable PutBucketOwnershipControlsCallable(const PutBucketOwnershipControlsRequestT& request) const { return SubmitCallable(&S3Client::PutBucketOwnershipControls, request); } /** * An Async wrapper for PutBucketOwnershipControls that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketOwnershipControlsAsync(const PutBucketOwnershipControlsRequestT& request, const PutBucketOwnershipControlsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketOwnershipControls, request, handler, context); } /** *

Applies an Amazon S3 bucket policy to an Amazon S3 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 PutBucketPolicy * permissions on the specified bucket and belong to the bucket owner's account in * order to use this operation.

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 operation, even if the policy explicitly denies the root * user the ability to perform this action.

For more * information, see Bucket * policy examples.

The following operations are related to * PutBucketPolicy:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketPolicyOutcome PutBucketPolicy(const Model::PutBucketPolicyRequest& request) const; /** * A Callable wrapper for PutBucketPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketPolicyOutcomeCallable PutBucketPolicyCallable(const PutBucketPolicyRequestT& request) const { return SubmitCallable(&S3Client::PutBucketPolicy, request); } /** * An Async wrapper for PutBucketPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketPolicyAsync(const PutBucketPolicyRequestT& request, const PutBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketPolicy, request, handler, context); } /** *

Creates a replication configuration or replaces an existing one. For more * information, see Replication * in the Amazon S3 User Guide.

Specify the replication * configuration in the request body. In the replication configuration, you provide * the name of the destination bucket or buckets where you want Amazon S3 to * replicate objects, the IAM role that Amazon S3 can assume to replicate objects * on your behalf, and other relevant information.

A replication * configuration must include at least one rule, and can contain a maximum of * 1,000. Each rule identifies a subset of objects to replicate by filtering the * objects in the source bucket. To choose additional subsets of objects to * replicate, add a rule for each subset.

To specify a subset of the objects * in the source bucket to apply a replication rule to, add the Filter element as a * child of the Rule element. You can filter objects based on an object key prefix, * one or more object tags, or both. When you add the Filter element in the * configuration, you must also add the following elements: * DeleteMarkerReplication, Status, and * Priority.

If you are using an earlier version of the * replication configuration, Amazon S3 handles replication of delete markers * differently. For more information, see Backward * Compatibility.

For information about enabling versioning on a * bucket, see Using * Versioning.

Handling Replication of Encrypted Objects

*

By default, Amazon S3 doesn't replicate objects that are stored at rest using * server-side encryption with KMS keys. To replicate Amazon Web Services * KMS-encrypted objects, add the following: SourceSelectionCriteria, * SseKmsEncryptedObjects, Status, * EncryptionConfiguration, and ReplicaKmsKeyID. For * information about replication configuration, see Replicating * Objects Created with SSE Using KMS keys.

For information on * PutBucketReplication errors, see List * of replication-related error codes

Permissions

To * create a PutBucketReplication request, you must have * s3:PutReplicationConfiguration permissions for the bucket.

*

By default, a resource owner, in this case the Amazon Web Services account * that created the bucket, can perform this operation. The resource owner can also * grant others permissions to perform the operation. For more information about * permissions, see Specifying * Permissions in a Policy and Managing * Access Permissions to Your Amazon S3 Resources.

To perform * this operation, the user or role performing the action must have the iam:PassRole * permission.

The following operations are related to * PutBucketReplication:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketReplicationOutcome PutBucketReplication(const Model::PutBucketReplicationRequest& request) const; /** * A Callable wrapper for PutBucketReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketReplicationOutcomeCallable PutBucketReplicationCallable(const PutBucketReplicationRequestT& request) const { return SubmitCallable(&S3Client::PutBucketReplication, request); } /** * An Async wrapper for PutBucketReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketReplicationAsync(const PutBucketReplicationRequestT& request, const PutBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketReplication, request, handler, context); } /** *

Sets the request payment configuration for a bucket. By default, the bucket * owner pays for downloads from the bucket. This configuration parameter enables * the bucket owner (only) to specify that the person requesting the download will * be charged for the download. For more information, see Requester * Pays Buckets.

The following operations are related to * PutBucketRequestPayment:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketRequestPaymentOutcome PutBucketRequestPayment(const Model::PutBucketRequestPaymentRequest& request) const; /** * A Callable wrapper for PutBucketRequestPayment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketRequestPaymentOutcomeCallable PutBucketRequestPaymentCallable(const PutBucketRequestPaymentRequestT& request) const { return SubmitCallable(&S3Client::PutBucketRequestPayment, request); } /** * An Async wrapper for PutBucketRequestPayment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketRequestPaymentAsync(const PutBucketRequestPaymentRequestT& request, const PutBucketRequestPaymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketRequestPayment, request, handler, context); } /** *

Sets the tags for a bucket.

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 and Using * Cost Allocation in Amazon S3 Bucket Tags.

When this operation * sets the tags for a bucket, it will overwrite any current tags the bucket * already has. You cannot use this operation to add tags to an existing list of * tags.

To use this operation, you must have permissions to perform * the s3:PutBucketTagging action. The 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. Please try again.

  • Error * code: InternalError

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

*

The following operations are related to PutBucketTagging:

*

See Also:

AWS * API Reference

*/ virtual Model::PutBucketTaggingOutcome PutBucketTagging(const Model::PutBucketTaggingRequest& request) const; /** * A Callable wrapper for PutBucketTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketTaggingOutcomeCallable PutBucketTaggingCallable(const PutBucketTaggingRequestT& request) const { return SubmitCallable(&S3Client::PutBucketTagging, request); } /** * An Async wrapper for PutBucketTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketTaggingAsync(const PutBucketTaggingRequestT& request, const PutBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketTagging, request, handler, context); } /** *

Sets the versioning state of an existing bucket.

You can set the * versioning state with one of the following values:

* Enabled—Enables versioning for the objects in the bucket. All objects * added to the bucket receive a unique version ID.

* Suspended—Disables versioning for the objects in the bucket. All objects * added to the bucket receive the version ID null.

If the versioning state * has never been set on a bucket, it has no versioning state; a GetBucketVersioning * request does not return a versioning state value.

In order to enable MFA * Delete, you must be the bucket owner. If you are the bucket owner and want to * enable MFA Delete in the bucket versioning configuration, you must include the * x-amz-mfa request header and the Status and the * MfaDelete request elements in a request to set the versioning state * of the bucket.

If you have an object expiration lifecycle * policy in your non-versioned bucket and you want to maintain the same permanent * delete behavior when you enable versioning, you must add a noncurrent expiration * policy. The noncurrent expiration lifecycle policy will manage the deletes of * the noncurrent object versions in the version-enabled bucket. (A version-enabled * bucket maintains one current and zero or more noncurrent object versions.) For * more information, see Lifecycle * and Versioning.

Related Resources *

See Also:

AWS * API Reference

*/ virtual Model::PutBucketVersioningOutcome PutBucketVersioning(const Model::PutBucketVersioningRequest& request) const; /** * A Callable wrapper for PutBucketVersioning that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketVersioningOutcomeCallable PutBucketVersioningCallable(const PutBucketVersioningRequestT& request) const { return SubmitCallable(&S3Client::PutBucketVersioning, request); } /** * An Async wrapper for PutBucketVersioning that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketVersioningAsync(const PutBucketVersioningRequestT& request, const PutBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketVersioning, request, handler, context); } /** *

Sets the configuration of the website that is specified in the * website subresource. To configure a bucket as a website, you can * add this subresource on the bucket with website configuration information such * as the file name of the index document and any redirect rules. For more * information, see Hosting * Websites on Amazon S3.

This PUT action requires the * S3:PutBucketWebsite permission. By default, only the bucket owner * can configure the website attached to a bucket; however, bucket owners can allow * other users to set the website configuration by writing a bucket policy that * grants them the S3:PutBucketWebsite permission.

To redirect * all website requests sent to the bucket's website endpoint, you add a website * configuration with the following elements. Because all requests are sent to * another website, you don't need to provide index document name for the * bucket.

  • WebsiteConfiguration

  • * RedirectAllRequestsTo

  • HostName *

  • Protocol

If you want * granular control over redirects, you can use the following elements to add * routing rules that describe conditions for redirecting requests and information * about the redirect destination. In this case, the website configuration must * provide an index document for the bucket, because some requests might not be * redirected.

  • WebsiteConfiguration

  • *

    IndexDocument

  • Suffix

    *

  • ErrorDocument

  • Key *

  • RoutingRules

  • * RoutingRule

  • Condition

    • *

  • HttpErrorCodeReturnedEquals

  • * KeyPrefixEquals

  • Redirect

    *

  • Protocol

  • HostName *

  • ReplaceKeyPrefixWith

  • * ReplaceKeyWith

  • HttpRedirectCode *

Amazon S3 has a limitation of 50 routing rules per website * configuration. If you require more than 50 routing rules, you can use object * redirect. For more information, see Configuring * an Object Redirect in the Amazon S3 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::PutBucketWebsiteOutcome PutBucketWebsite(const Model::PutBucketWebsiteRequest& request) const; /** * A Callable wrapper for PutBucketWebsite that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketWebsiteOutcomeCallable PutBucketWebsiteCallable(const PutBucketWebsiteRequestT& request) const { return SubmitCallable(&S3Client::PutBucketWebsite, request); } /** * An Async wrapper for PutBucketWebsite that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketWebsiteAsync(const PutBucketWebsiteRequestT& request, const PutBucketWebsiteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutBucketWebsite, request, handler, context); } /** *

Adds an object to a bucket. You must have WRITE permissions on a bucket to * add an object to it.

Amazon S3 never adds partial objects; if you receive * a success response, Amazon S3 added the entire object to the bucket.

*

Amazon S3 is a distributed system. If it receives multiple write requests for * the same object simultaneously, it overwrites all but the last object written. * Amazon S3 does not provide object locking; if you need this, make sure to build * it into your application layer or use versioning instead.

To ensure that * data is not corrupted traversing the network, use the Content-MD5 * header. When you use this header, Amazon S3 checks the object against the * provided MD5 value and, if they do not match, returns an error. Additionally, * you can calculate the MD5 while putting an object to Amazon S3 and compare the * returned ETag to the calculated MD5 value.

  • To * successfully complete the PutObject request, you must have the * s3:PutObject in your IAM permissions.

  • To * successfully change the objects acl of your PutObject request, you * must have the s3:PutObjectAcl in your IAM permissions.

    • *

  • The Content-MD5 header is required for any request to * upload an object with a retention period configured using Amazon S3 Object Lock. * For more information about Amazon S3 Object Lock, see Amazon * S3 Object Lock Overview in the Amazon S3 User Guide.

*

Server-side Encryption

You can optionally request * server-side encryption. With server-side encryption, Amazon S3 encrypts your * data as it writes it to disks in its data centers and decrypts the data when you * access it. You have the option to provide your own encryption key or use Amazon * Web Services managed encryption keys (SSE-S3 or SSE-KMS). For more information, * see Using * Server-Side Encryption.

If you request server-side encryption using * Amazon Web Services Key Management Service (SSE-KMS), you can enable an S3 * Bucket Key at the object-level. For more information, see Amazon S3 * Bucket Keys in the Amazon S3 User Guide.

Access Control * List (ACL)-Specific Request Headers

You can use headers to grant * ACL- based permissions. By default, all objects are private. Only the owner has * full access control. When adding a new object, you can grant permissions to * individual Amazon Web Services accounts or to predefined groups defined by * Amazon S3. These permissions are then added to the ACL on the object. For more * information, see Access * Control List (ACL) Overview and Managing * ACLs Using the REST API.

If the bucket that you're uploading objects * to uses the bucket owner enforced setting for S3 Object Ownership, ACLs are * disabled and no longer affect permissions. Buckets that use this setting only * accept PUT requests that don't specify an ACL or PUT requests that specify * bucket owner full control ACLs, such as the * bucket-owner-full-control canned ACL or an equivalent form of this * ACL expressed in the XML format. PUT requests that contain other ACLs (for * example, custom grants to certain Amazon Web Services accounts) fail and return * a 400 error with the error code * AccessControlListNotSupported.

For more information, see * Controlling ownership of objects and disabling ACLs in the Amazon S3 User * Guide.

If your bucket uses the bucket owner enforced setting * for Object Ownership, all objects written to the bucket by any account will be * owned by the bucket owner.

Storage Class Options

*

By default, Amazon S3 uses the STANDARD Storage Class to store newly created * objects. The STANDARD storage class provides high durability and high * availability. Depending on performance needs, you can specify a different * Storage Class. Amazon S3 on Outposts only uses the OUTPOSTS Storage Class. For * more information, see Storage * Classes in the Amazon S3 User Guide.

Versioning

*

If you enable versioning for a bucket, Amazon S3 automatically generates a * unique version ID for the object being stored. Amazon S3 returns this ID in the * response. When you enable versioning for a bucket, if Amazon S3 receives * multiple write requests for the same object simultaneously, it stores all of the * objects.

For more information about versioning, see Adding * Objects to Versioning Enabled Buckets. For information about returning the * versioning state of a bucket, see GetBucketVersioning. *

Related Resources

See Also:

AWS API * Reference

*/ virtual Model::PutObjectOutcome PutObject(const Model::PutObjectRequest& request) const; /** * A Callable wrapper for PutObject that returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::PutObjectOutcomeCallable PutObjectCallable(const Model::PutObjectRequest& request) const; /** * An Async wrapper for PutObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void PutObjectAsync(const Model::PutObjectRequest& request, const PutObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Uses the acl subresource to set the access control list (ACL) * permissions for a new or existing object in an S3 bucket. You must have * WRITE_ACP permission to set the ACL of an object. For more * information, see What * permissions can I grant? in the Amazon S3 User Guide.

This * action is not supported by Amazon S3 on Outposts.

Depending on your * application needs, you can choose to set the ACL on an object using either the * request body or the headers. For example, if you have an existing application * that updates a bucket ACL using the request body, you can continue to use that * approach. For more information, see Access * Control List (ACL) Overview in the Amazon S3 User Guide.

*

If your bucket uses the bucket owner enforced setting for S3 * Object Ownership, ACLs are disabled and no longer affect permissions. You must * use policies to grant access to your bucket and the objects in it. Requests to * set ACLs or update ACLs fail and return the * AccessControlListNotSupported error code. Requests to read ACLs are * still supported. For more information, see Controlling * object ownership in the Amazon S3 User Guide.

* Access Permissions

You can set access permissions using one of * the following methods:

  • Specify a canned ACL with the * x-amz-acl request header. Amazon S3 supports a set of predefined * ACLs, known as canned ACLs. Each canned ACL has a predefined set of grantees and * permissions. Specify the canned ACL name as the value of x-amz-acl. * If you use this header, you cannot use other access control-specific headers in * your request. For more information, see Canned * ACL.

  • Specify access permissions explicitly with the * x-amz-grant-read, x-amz-grant-read-acp, * x-amz-grant-write-acp, and x-amz-grant-full-control * headers. When using these headers, you specify explicit access permissions and * grantees (Amazon Web Services accounts or Amazon S3 groups) who will receive the * permission. If you use these ACL-specific headers, you cannot use * x-amz-acl header to set a canned ACL. These parameters map to the * set of permissions that Amazon S3 supports in an ACL. For more information, see * Access * Control List (ACL) Overview.

    You specify each grantee as a type=value * pair, where the type is one of the following:

    • id * – if the value specified is the canonical user ID of an Amazon Web Services * account

    • uri – if you are granting permissions to * a predefined group

    • emailAddress – if the value * specified is the email address of an Amazon Web Services account

      *

      Using email addresses to specify a grantee is only supported in the following * Amazon Web Services Regions:

      • US East (N. Virginia)

        • *

      • US West (N. California)

      • US West (Oregon)

        • *

      • Asia Pacific (Singapore)

      • Asia Pacific (Sydney)

        *

      • Asia Pacific (Tokyo)

      • Europe (Ireland)

        • *

      • South America (São Paulo)

      For a list of all the * Amazon S3 supported Regions and endpoints, see Regions * and Endpoints in the Amazon Web Services General Reference.

      *

    For example, the following x-amz-grant-read header * grants list objects permission to the two Amazon Web Services accounts * identified by their email addresses.

    x-amz-grant-read: * emailAddress="xyz@amazon.com", emailAddress="abc@amazon.com"

    • *

You can use either a canned ACL or specify access permissions * explicitly. You cannot do both.

Grantee Values

You can * specify the person (grantee) to whom you're assigning access rights (using * request elements) in the following ways:

  • By the person's * ID:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="CanonicalUser"><ID><>ID<></ID><DisplayName><>GranteesEmail<></DisplayName> * </Grantee>

    DisplayName is optional and ignored in the * request.

  • By URI:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="Group"><URI><>http://acs.amazonaws.com/groups/global/AuthenticatedUsers<></URI></Grantee> *

  • By Email address:

    <Grantee * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" * xsi:type="AmazonCustomerByEmail"><EmailAddress><>Grantees@email.com<></EmailAddress>lt;/Grantee> *

    The grantee is resolved to the CanonicalUser and, in a response to a GET * Object acl request, appears as the CanonicalUser.

    Using email * addresses to specify a grantee is only supported in the following Amazon Web * Services Regions:

    • US East (N. Virginia)

    • US * West (N. California)

    • US West (Oregon)

    • Asia * Pacific (Singapore)

    • Asia Pacific (Sydney)

    • *

      Asia Pacific (Tokyo)

    • Europe (Ireland)

    • *

      South America (São Paulo)

    For a list of all the Amazon S3 * supported Regions and endpoints, see Regions * and Endpoints in the Amazon Web Services General Reference.

    *

Versioning

The ACL of an object is set at the * object version level. By default, PUT sets the ACL of the current version of an * object. To set the ACL of a different version, use the versionId * subresource.

Related Resources

See Also:

AWS API * Reference

*/ virtual Model::PutObjectAclOutcome PutObjectAcl(const Model::PutObjectAclRequest& request) const; /** * A Callable wrapper for PutObjectAcl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutObjectAclOutcomeCallable PutObjectAclCallable(const PutObjectAclRequestT& request) const { return SubmitCallable(&S3Client::PutObjectAcl, request); } /** * An Async wrapper for PutObjectAcl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutObjectAclAsync(const PutObjectAclRequestT& request, const PutObjectAclResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutObjectAcl, request, handler, context); } /** *

Applies a legal hold configuration to the specified object. For more * information, see Locking * Objects.

This action is not supported by Amazon S3 on * Outposts.

See Also:

AWS * API Reference

*/ virtual Model::PutObjectLegalHoldOutcome PutObjectLegalHold(const Model::PutObjectLegalHoldRequest& request) const; /** * A Callable wrapper for PutObjectLegalHold that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutObjectLegalHoldOutcomeCallable PutObjectLegalHoldCallable(const PutObjectLegalHoldRequestT& request) const { return SubmitCallable(&S3Client::PutObjectLegalHold, request); } /** * An Async wrapper for PutObjectLegalHold that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutObjectLegalHoldAsync(const PutObjectLegalHoldRequestT& request, const PutObjectLegalHoldResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutObjectLegalHold, request, handler, context); } /** *

Places an Object Lock configuration on the specified bucket. The rule * specified in the Object Lock configuration will be applied by default to every * new object placed in the specified bucket. For more information, see Locking * Objects.

  • The DefaultRetention settings * require both a mode and a period.

  • The * DefaultRetention period can be either Days or * Years but you must select one. You cannot specify Days * and Years at the same time.

  • You can only enable * Object Lock for new buckets. If you want to turn on Object Lock for an existing * bucket, contact Amazon Web Services Support.

See * Also:

AWS * API Reference

*/ virtual Model::PutObjectLockConfigurationOutcome PutObjectLockConfiguration(const Model::PutObjectLockConfigurationRequest& request) const; /** * A Callable wrapper for PutObjectLockConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutObjectLockConfigurationOutcomeCallable PutObjectLockConfigurationCallable(const PutObjectLockConfigurationRequestT& request) const { return SubmitCallable(&S3Client::PutObjectLockConfiguration, request); } /** * An Async wrapper for PutObjectLockConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutObjectLockConfigurationAsync(const PutObjectLockConfigurationRequestT& request, const PutObjectLockConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutObjectLockConfiguration, request, handler, context); } /** *

Places an Object Retention configuration on an object. For more information, * see Locking * Objects. Users or accounts require the s3:PutObjectRetention * permission in order to place an Object Retention configuration on objects. * Bypassing a Governance Retention configuration requires the * s3:BypassGovernanceRetention permission.

This action is not * supported by Amazon S3 on Outposts.

See Also:

AWS * API Reference

*/ virtual Model::PutObjectRetentionOutcome PutObjectRetention(const Model::PutObjectRetentionRequest& request) const; /** * A Callable wrapper for PutObjectRetention that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutObjectRetentionOutcomeCallable PutObjectRetentionCallable(const PutObjectRetentionRequestT& request) const { return SubmitCallable(&S3Client::PutObjectRetention, request); } /** * An Async wrapper for PutObjectRetention that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutObjectRetentionAsync(const PutObjectRetentionRequestT& request, const PutObjectRetentionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutObjectRetention, request, handler, context); } /** *

Sets the supplied tag-set to an object that already exists in a bucket.

*

A tag is a key-value pair. You can associate tags with an object by sending a * PUT request against the tagging subresource that is associated with the object. * You can retrieve tags by sending a GET request. For more information, see GetObjectTagging.

*

For tagging-related restrictions related to characters and encodings, see Tag * Restrictions. Note that Amazon S3 limits the maximum number of tags to 10 * tags per object.

To use this operation, you must have permission to * perform the s3:PutObjectTagging action. By default, the bucket * owner has this permission and can grant this permission to others.

To put * tags of any other version, use the versionId query parameter. You * also need permission for the s3:PutObjectVersionTagging action.

*

For information about the Amazon S3 object tagging feature, see Object * Tagging.

Special Errors

    • *

    • Code: InvalidTagError

    • Cause: The tag * provided was not a valid tag. This error can occur if the tag did not pass input * validation. For more information, see Object * Tagging.

    • Code: * MalformedXMLError

    • Cause: The XML provided does not * match the schema.

    • Code: * OperationAbortedError

    • Cause: A conflicting * conditional action is currently in progress against this resource. Please try * again.

    • Code: InternalError *

    • Cause: The service was unable to apply the provided tag * to the object.

Related * Resources

See Also:

AWS * API Reference

*/ virtual Model::PutObjectTaggingOutcome PutObjectTagging(const Model::PutObjectTaggingRequest& request) const; /** * A Callable wrapper for PutObjectTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutObjectTaggingOutcomeCallable PutObjectTaggingCallable(const PutObjectTaggingRequestT& request) const { return SubmitCallable(&S3Client::PutObjectTagging, request); } /** * An Async wrapper for PutObjectTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutObjectTaggingAsync(const PutObjectTaggingRequestT& request, const PutObjectTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutObjectTagging, request, handler, context); } /** *

Creates or modifies the PublicAccessBlock configuration for an * Amazon S3 bucket. To use this operation, you must have the * s3:PutBucketPublicAccessBlock permission. For more information * about Amazon S3 permissions, see Specifying * Permissions in a Policy.

When Amazon S3 evaluates the * PublicAccessBlock configuration for a bucket or an object, it * checks the PublicAccessBlock configuration for both the bucket (or * the bucket that contains the object) and the bucket owner's account. If the * PublicAccessBlock configurations are different between the bucket * and the account, Amazon S3 uses the most restrictive combination of the * bucket-level and account-level settings.

For more * information about when Amazon S3 considers a bucket or an object public, see The * Meaning of "Public".

Related Resources

*

See Also:

AWS * API Reference

*/ virtual Model::PutPublicAccessBlockOutcome PutPublicAccessBlock(const Model::PutPublicAccessBlockRequest& request) const; /** * A Callable wrapper for PutPublicAccessBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutPublicAccessBlockOutcomeCallable PutPublicAccessBlockCallable(const PutPublicAccessBlockRequestT& request) const { return SubmitCallable(&S3Client::PutPublicAccessBlock, request); } /** * An Async wrapper for PutPublicAccessBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutPublicAccessBlockAsync(const PutPublicAccessBlockRequestT& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::PutPublicAccessBlock, request, handler, context); } /** *

Restores an archived copy of an object back into Amazon S3

This action * is not supported by Amazon S3 on Outposts.

This action performs the * following types of requests:

  • select - Perform a * select query on an archived object

  • restore an * archive - Restore an archived object

To use this * operation, you must have permissions to perform the * s3:RestoreObject action. The 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 in the Amazon S3 User * Guide.

Querying Archives with Select Requests

You use * a select type of request to perform SQL queries on archived objects. The * archived objects that are being queried by the select request must be formatted * as uncompressed comma-separated values (CSV) files. You can run queries and * custom analytics on your archived data without having to restore your data to a * hotter Amazon S3 tier. For an overview about select requests, see Querying * Archived Objects in the Amazon S3 User Guide.

When making a * select request, do the following:

  • Define an output location for * the select query's output. This must be an Amazon S3 bucket in the same Amazon * Web Services Region as the bucket that contains the archive object that is being * queried. The Amazon Web Services account that initiates the job must have * permissions to write to the S3 bucket. You can specify the storage class and * encryption for the output objects stored in the bucket. For more information * about output, see Querying * Archived Objects in the Amazon S3 User Guide.

    For more * information about the S3 structure in the request body, see the * following:

  • Define the SQL expression for the SELECT * type of restoration for your query in the request body's * SelectParameters structure. You can use expressions like the * following examples.

    • The following expression returns all * records from the specified object.

      SELECT * FROM Object *

    • Assuming that you are not using any headers for data stored * in the object, you can specify columns with positional headers.

      * SELECT s._1, s._2 FROM Object s WHERE s._3 > 100

    • *

      If you have headers and you set the fileHeaderInfo in the * CSV structure in the request body to USE, you can * specify headers in the query. (If you set the fileHeaderInfo field * to IGNORE, the first row is skipped for the query.) You cannot mix * ordinal positions with header column names.

      SELECT s.Id, * s.FirstName, s.SSN FROM S3Object s

For * more information about using SQL with S3 Glacier Select restore, see SQL * Reference for Amazon S3 Select and S3 Glacier Select in the Amazon S3 * User Guide.

When making a select request, you can also do the * following:

  • To expedite your queries, specify the * Expedited tier. For more information about tiers, see "Restoring * Archives," later in this topic.

  • Specify details about the data * serialization format of both the input object that is being queried and the * serialization of the CSV-encoded query results.

The following * are additional important facts about the select feature:

  • The * output results are new Amazon S3 objects. Unlike archive retrievals, they are * stored until explicitly deleted-manually or through a lifecycle policy.

    *

  • You can issue more than one select request on the same Amazon S3 * object. Amazon S3 doesn't deduplicate requests, so avoid issuing duplicate * requests.

  • Amazon S3 accepts a select request even if the * object has already been restored. A select request doesn’t return error response * 409.

Restoring objects

Objects * that you archive to the S3 Glacier or S3 Glacier Deep Archive storage class, and * S3 Intelligent-Tiering Archive or S3 Intelligent-Tiering Deep Archive tiers are * not accessible in real time. For objects in Archive Access or Deep Archive * Access tiers you must first initiate a restore request, and then wait until the * object is moved into the Frequent Access tier. For objects in S3 Glacier or S3 * Glacier Deep Archive storage classes you must first initiate a restore request, * and then wait until a temporary copy of the object is available. To access an * archived object, you must restore the object for the duration (number of days) * that you specify.

To restore a specific object version, you can provide a * version ID. If you don't provide a version ID, Amazon S3 restores the current * version.

When restoring an archived object (or using a select request), * you can specify one of the following data access tier options in the * Tier element of the request body:

  • * Expedited - Expedited retrievals allow you to quickly access your * data stored in the S3 Glacier storage class or S3 Intelligent-Tiering Archive * tier when occasional urgent requests for a subset of archives are required. For * all but the largest archived objects (250 MB+), data accessed using Expedited * retrievals is typically made available within 1–5 minutes. Provisioned capacity * ensures that retrieval capacity for Expedited retrievals is available when you * need it. Expedited retrievals and provisioned capacity are not available for * objects stored in the S3 Glacier Deep Archive storage class or S3 * Intelligent-Tiering Deep Archive tier.

  • Standard * - Standard retrievals allow you to access any of your archived objects within * several hours. This is the default option for retrieval requests that do not * specify the retrieval option. Standard retrievals typically finish within 3–5 * hours for objects stored in the S3 Glacier storage class or S3 * Intelligent-Tiering Archive tier. They typically finish within 12 hours for * objects stored in the S3 Glacier Deep Archive storage class or S3 * Intelligent-Tiering Deep Archive tier. Standard retrievals are free for objects * stored in S3 Intelligent-Tiering.

  • Bulk - Bulk * retrievals are the lowest-cost retrieval option in S3 Glacier, enabling you to * retrieve large amounts, even petabytes, of data inexpensively. Bulk retrievals * typically finish within 5–12 hours for objects stored in the S3 Glacier storage * class or S3 Intelligent-Tiering Archive tier. They typically finish within 48 * hours for objects stored in the S3 Glacier Deep Archive storage class or S3 * Intelligent-Tiering Deep Archive tier. Bulk retrievals are free for objects * stored in S3 Intelligent-Tiering.

For more information about * archive retrieval options and provisioned capacity for Expedited * data access, see Restoring * Archived Objects in the Amazon S3 User Guide.

You can use * Amazon S3 restore speed upgrade to change the restore speed to a faster speed * while it is in progress. For more information, see * Upgrading the speed of an in-progress restore in the Amazon S3 User * Guide.

To get the status of object restoration, you can send a * HEAD request. Operations return the x-amz-restore * header, which provides information about the restoration status, in the * response. You can use Amazon S3 event notifications to notify you when a restore * is initiated or completed. For more information, see Configuring * Amazon S3 Event Notifications in the Amazon S3 User Guide.

*

After restoring an archived object, you can update the restoration period by * reissuing the request with a new period. Amazon S3 updates the restoration * period relative to the current time and charges only for the request-there are * no data transfer charges. You cannot update the restoration period when Amazon * S3 is actively processing your current restore request for the object.

If * your bucket has a lifecycle configuration with a rule that includes an * expiration action, the object expiration overrides the life span that you * specify in a restore request. For example, if you restore an object copy for 10 * days, but the object is scheduled to expire in 3 days, Amazon S3 deletes the * object in 3 days. For more information about lifecycle configuration, see PutBucketLifecycleConfiguration * and Object * Lifecycle Management in Amazon S3 User Guide.

* Responses

A successful action returns either the 200 * OK or 202 Accepted status code.

  • If the * object is not previously restored, then Amazon S3 returns 202 * Accepted in the response.

  • If the object is previously * restored, Amazon S3 returns 200 OK in the response.

    • *

Special Errors

    • * Code: RestoreAlreadyInProgress

    • Cause: Object * restore is already in progress. (This error does not apply to SELECT type * requests.)

    • HTTP Status Code: 409 Conflict

      *

    • SOAP Fault Code Prefix: Client

  • *

    • Code: GlacierExpeditedRetrievalNotAvailable

    • *

      Cause: expedited retrievals are currently not available. Try again later. * (Returned if there is insufficient capacity to process the Expedited request. * This error applies only to Expedited retrievals and not to S3 Standard or Bulk * retrievals.)

    • HTTP Status Code: 503

      • *

    • SOAP Fault Code Prefix: N/A

Related Resources

See Also:

AWS * API Reference

*/ virtual Model::RestoreObjectOutcome RestoreObject(const Model::RestoreObjectRequest& request) const; /** * A Callable wrapper for RestoreObject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreObjectOutcomeCallable RestoreObjectCallable(const RestoreObjectRequestT& request) const { return SubmitCallable(&S3Client::RestoreObject, request); } /** * An Async wrapper for RestoreObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreObjectAsync(const RestoreObjectRequestT& request, const RestoreObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::RestoreObject, request, handler, context); } /** *

This action filters the contents of an Amazon S3 object based on a simple * structured query language (SQL) statement. In the request, along with the SQL * expression, you must also specify a data serialization format (JSON, CSV, or * Apache Parquet) of the object. Amazon S3 uses this format to parse object data * into records, and returns only records that match the specified SQL expression. * You must also specify the data serialization format for the response.

*

This action is not supported by Amazon S3 on Outposts.

For more * information about Amazon S3 Select, see Selecting * Content from Objects and SELECT * Command in the Amazon S3 User Guide.

For more information * about using SQL with Amazon S3 Select, see * SQL Reference for Amazon S3 Select and S3 Glacier Select in the Amazon S3 * User Guide.

Permissions

You must have * s3:GetObject permission for this operation. Amazon S3 Select does * not support anonymous access. For more information about permissions, see Specifying * Permissions in a Policy in the Amazon S3 User Guide.

* Object Data Formats

You can use Amazon S3 Select to query objects * that have the following format properties:

  • CSV, JSON, and * Parquet - Objects must be in CSV, JSON, or Parquet format.

  • *

    UTF-8 - UTF-8 is the only encoding type Amazon S3 Select * supports.

  • GZIP or BZIP2 - CSV and JSON files can be * compressed using GZIP or BZIP2. GZIP and BZIP2 are the only compression formats * that Amazon S3 Select supports for CSV and JSON files. Amazon S3 Select supports * columnar compression for Parquet using GZIP or Snappy. Amazon S3 Select does not * support whole-object compression for Parquet objects.

  • * Server-side encryption - Amazon S3 Select supports querying objects that * are protected with server-side encryption.

    For objects that are encrypted * with customer-provided encryption keys (SSE-C), you must use HTTPS, and you must * use the headers that are documented in the GetObject. * For more information about SSE-C, see Server-Side * Encryption (Using Customer-Provided Encryption Keys) in the Amazon S3 * User Guide.

    For objects that are encrypted with Amazon S3 managed * encryption keys (SSE-S3) and Amazon Web Services KMS keys (SSE-KMS), server-side * encryption is handled transparently, so you don't need to specify anything. For * more information about server-side encryption, including SSE-S3 and SSE-KMS, see * Protecting * Data Using Server-Side Encryption in the Amazon S3 User Guide.

    *

Working with the Response Body

Given the response * size is unknown, Amazon S3 Select streams the response as a series of messages * and includes a Transfer-Encoding header with chunked * as its value in the response. For more information, see Appendix: * SelectObjectContent Response.

GetObject Support

*

The SelectObjectContent action does not support the following * GetObject functionality. For more information, see GetObject.

*

  • Range: Although you can specify a scan range for an * Amazon S3 Select request (see SelectObjectContentRequest * - ScanRange in the request parameters), you cannot specify the range of * bytes of an object to return.

  • GLACIER, DEEP_ARCHIVE and * REDUCED_REDUNDANCY storage classes: You cannot specify the GLACIER, * DEEP_ARCHIVE, or REDUCED_REDUNDANCY storage classes. For more * information, about storage classes see Storage * Classes in the Amazon S3 User Guide.

* Special Errors

For a list of special errors for this operation, * see List * of SELECT Object Content Error Codes

Related * Resources

See Also:

AWS * API Reference

*/ virtual Model::SelectObjectContentOutcome SelectObjectContent(Model::SelectObjectContentRequest& request) const; /** * A Callable wrapper for SelectObjectContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SelectObjectContentOutcomeCallable SelectObjectContentCallable(SelectObjectContentRequestT& request) const { return SubmitCallable(&S3Client::SelectObjectContent, request); } /** * An Async wrapper for SelectObjectContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SelectObjectContentAsync(SelectObjectContentRequestT& request, const SelectObjectContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::SelectObjectContent, request, handler, context); } /** *

Uploads a part in a multipart upload.

In this operation, you * provide part data in your request. However, you have an option to specify your * existing Amazon S3 object as a data source for the part you are uploading. To * upload a part from an existing object, you use the UploadPartCopy * operation.

You must initiate a multipart upload (see CreateMultipartUpload) * before you can upload any part. In response to your initiate request, Amazon S3 * returns an upload ID, a unique identifier, that you must include in your upload * part request.

Part numbers can be any number from 1 to 10,000, inclusive. * A part number uniquely identifies a part and also defines its position within * the object being created. If you upload a new part using the same part number * that was used with a previous part, the previously uploaded part is * overwritten.

For information about maximum and minimum part sizes and * other multipart upload specifications, see Multipart * upload limits in the Amazon S3 User Guide.

To ensure that data * is not corrupted when traversing the network, specify the * Content-MD5 header in the upload part request. Amazon S3 checks the * part data against the provided MD5 value. If they do not match, Amazon S3 * returns an error.

If the upload request is signed with Signature Version * 4, then Amazon Web Services S3 uses the x-amz-content-sha256 header * as a checksum instead of Content-MD5. For more information see Authenticating * Requests: Using the Authorization Header (Amazon Web Services Signature Version * 4).

Note: After you initiate multipart upload and upload one * or more parts, you must either complete or abort multipart upload in order to * stop getting charged for storage of the uploaded parts. Only after you either * complete or abort multipart upload, Amazon S3 frees up the parts storage and * stops charging you for the parts storage.

For more information on * multipart uploads, go to Multipart * Upload Overview in the Amazon S3 User Guide .

For information * on the permissions required to use the multipart upload API, go to Multipart * Upload and Permissions in the Amazon S3 User Guide.

You can * optionally request server-side encryption where Amazon S3 encrypts your data as * it writes it to disks in its data centers and decrypts it for you when you * access it. You have the option of providing your own encryption key, or you can * use the Amazon Web Services managed encryption keys. If you choose to provide * your own encryption key, the request headers you provide in the request must * match the headers you used in the request to initiate the upload by using CreateMultipartUpload. * For more information, go to Using * Server-Side Encryption in the Amazon S3 User Guide.

*

Server-side encryption is supported by the S3 Multipart Upload actions. * Unless you are using a customer-provided encryption key, you don't need to * specify the encryption parameters in each UploadPart request. Instead, you only * need to specify the server-side encryption parameters in the initial Initiate * Multipart request. For more information, see CreateMultipartUpload.

*

If you requested server-side encryption using a customer-provided encryption * key in your initiate multipart upload request, you must provide identical * encryption information in each part upload using the following headers.

    *

  • x-amz-server-side-encryption-customer-algorithm

  • *

    x-amz-server-side-encryption-customer-key

  • *

    x-amz-server-side-encryption-customer-key-MD5

Special Errors

    • Code: * NoSuchUpload

    • Cause: The specified multipart upload * does not exist. The upload ID might be invalid, or the multipart upload might * have been aborted or completed.

    • HTTP Status Code: * 404 Not Found

    • SOAP Fault Code Prefix: Client *

Related Resources

*

See Also:

AWS API * Reference

*/ virtual Model::UploadPartOutcome UploadPart(const Model::UploadPartRequest& request) const; /** * A Callable wrapper for UploadPart that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UploadPartOutcomeCallable UploadPartCallable(const UploadPartRequestT& request) const { return SubmitCallable(&S3Client::UploadPart, request); } /** * An Async wrapper for UploadPart that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UploadPartAsync(const UploadPartRequestT& request, const UploadPartResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::UploadPart, request, handler, context); } /** *

Uploads a part by copying data from an existing object as data source. You * specify the data source by adding the request header * x-amz-copy-source in your request and a byte range by adding the * request header x-amz-copy-source-range in your request.

For * information about maximum and minimum part sizes and other multipart upload * specifications, see Multipart * upload limits in the Amazon S3 User Guide.

Instead of * using an existing object as part data, you might use the UploadPart * action and provide data in your request.

You must initiate a * multipart upload before you can upload any part. In response to your initiate * request. Amazon S3 returns a unique identifier, the upload ID, that you must * include in your upload part request.

For more information about using the * UploadPartCopy operation, see the following:

  • For * conceptual information about multipart uploads, see Uploading * Objects Using Multipart Upload in the Amazon S3 User Guide.

    • *

  • For information about permissions required to use the multipart upload * API, see Multipart * Upload and Permissions in the Amazon S3 User Guide.

  • *

    For information about copying objects using a single atomic action vs. a * multipart upload, see Operations * on Objects in the Amazon S3 User Guide.

  • For * information about using server-side encryption with customer-provided encryption * keys with the UploadPartCopy operation, see CopyObject * and UploadPart.

    *

Note the following additional considerations about the request * headers x-amz-copy-source-if-match, * x-amz-copy-source-if-none-match, * x-amz-copy-source-if-unmodified-since, and * x-amz-copy-source-if-modified-since:

  • * Consideration 1 - If both of the x-amz-copy-source-if-match * and x-amz-copy-source-if-unmodified-since headers are present in * the request as follows:

    x-amz-copy-source-if-match * condition evaluates to true, and;

    * x-amz-copy-source-if-unmodified-since condition evaluates to * false;

    Amazon S3 returns 200 OK and copies the * data.

  • Consideration 2 - If both of the * x-amz-copy-source-if-none-match and * x-amz-copy-source-if-modified-since headers are present in the * request as follows:

    x-amz-copy-source-if-none-match * condition evaluates to false, and;

    * x-amz-copy-source-if-modified-since condition evaluates to * true;

    Amazon S3 returns 412 Precondition Failed * response code.

Versioning

If your bucket has * versioning enabled, you could have multiple versions of the same object. By * default, x-amz-copy-source identifies the current version of the * object to copy. If the current version is a delete marker and you don't specify * a versionId in the x-amz-copy-source, Amazon S3 returns a 404 * error, because the object does not exist. If you specify versionId in the * x-amz-copy-source and the versionId is a delete marker, Amazon S3 * returns an HTTP 400 error, because you are not allowed to specify a delete * marker as a version for the x-amz-copy-source.

You can * optionally specify a specific version of the source object to copy by adding the * versionId subresource as shown in the following example:

* x-amz-copy-source: /bucket/object?versionId=version id

Special Errors

    • Code: * NoSuchUpload

    • Cause: The specified multipart upload * does not exist. The upload ID might be invalid, or the multipart upload might * have been aborted or completed.

    • HTTP Status Code: 404 * Not Found

    • Code: * InvalidRequest

    • Cause: The specified copy source is * not supported as a byte-range copy source.

    • HTTP * Status Code: 400 Bad Request

* Related Resources

See Also:

AWS * API Reference

*/ virtual Model::UploadPartCopyOutcome UploadPartCopy(const Model::UploadPartCopyRequest& request) const; /** * A Callable wrapper for UploadPartCopy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UploadPartCopyOutcomeCallable UploadPartCopyCallable(const UploadPartCopyRequestT& request) const { return SubmitCallable(&S3Client::UploadPartCopy, request); } /** * An Async wrapper for UploadPartCopy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UploadPartCopyAsync(const UploadPartCopyRequestT& request, const UploadPartCopyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::UploadPartCopy, request, handler, context); } /** *

Passes transformed objects to a GetObject operation when using * Object Lambda access points. For information about Object Lambda access points, * see Transforming * objects with Object Lambda access points in the Amazon S3 User * Guide.

This operation supports metadata that can be returned by GetObject, * in addition to RequestRoute, RequestToken, * StatusCode, ErrorCode, and ErrorMessage. * The GetObject response metadata is supported so that the * WriteGetObjectResponse caller, typically an Lambda function, can * provide the same metadata when it internally invokes GetObject. * When WriteGetObjectResponse is called by a customer-owned Lambda * function, the metadata returned to the end user GetObject call * might differ from what Amazon S3 would normally return.

You can include * any number of metadata headers. When including a metadata header, it should be * prefaced with x-amz-meta. For example, * x-amz-meta-my-custom-header: MyCustomValue. The primary use case * for this is to forward GetObject metadata.

Amazon Web * Services provides some prebuilt Lambda functions that you can use with S3 Object * Lambda to detect and redact personally identifiable information (PII) and * decompress S3 objects. These Lambda functions are available in the Amazon Web * Services Serverless Application Repository, and can be selected through the * Amazon Web Services Management Console when you create your Object Lambda access * point.

Example 1: PII Access Control - This Lambda function uses Amazon * Comprehend, a natural language processing (NLP) service using machine learning * to find insights and relationships in text. It automatically detects personally * identifiable information (PII) such as names, addresses, dates, credit card * numbers, and social security numbers from documents in your Amazon S3 bucket. *

Example 2: PII Redaction - This Lambda function uses Amazon Comprehend, * a natural language processing (NLP) service using machine learning to find * insights and relationships in text. It automatically redacts personally * identifiable information (PII) such as names, addresses, dates, credit card * numbers, and social security numbers from documents in your Amazon S3 bucket. *

Example 3: Decompression - The Lambda function * S3ObjectLambdaDecompression, is equipped to decompress objects stored in S3 in * one of six compressed file formats including bzip2, gzip, snappy, zlib, * zstandard and ZIP.

For information on how to view and use these * functions, see Using * Amazon Web Services built Lambda functions in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::WriteGetObjectResponseOutcome WriteGetObjectResponse(const Model::WriteGetObjectResponseRequest& request) const; /** * A Callable wrapper for WriteGetObjectResponse that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::WriteGetObjectResponseOutcomeCallable WriteGetObjectResponseCallable(const WriteGetObjectResponseRequestT& request) const { return SubmitCallable(&S3Client::WriteGetObjectResponse, request); } /** * An Async wrapper for WriteGetObjectResponse that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void WriteGetObjectResponseAsync(const WriteGetObjectResponseRequestT& request, const WriteGetObjectResponseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3Client::WriteGetObjectResponse, request, handler, context); } Aws::String GeneratePresignedUrl(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); Aws::String GeneratePresignedUrl(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, const Http::HeaderValueCollection& customizedHeaders, uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); /** * Server Side Encryption Headers and Algorithm * Method Algorithm Required Headers * SSE-S3 AES256 x-amz-server-side-encryption:AES256 * SSE-KMS aws:kms x-amz-server-side--encryption:aws:kms, x-amz-server-side-encryption-aws-kms-key-id: * SS3-C AES256 x-amz-server-side-encryption-customer-algorithm:AES256, x-amz-server-side-encryption-customer-key:, x-amz-server-side-encryption-customer-key-MD5: */ /** * Generate presigned URL with Sever Side Encryption(SSE) and with S3 managed keys. * https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html (algo: AES256) */ Aws::String GeneratePresignedUrlWithSSES3(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); /** * Generate presigned URL with Sever Side Encryption(SSE) and with S3 managed keys. * https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html (algo: AES256) * Header: "x-amz-server-side-encryption" will be added internally, don't customize it. */ Aws::String GeneratePresignedUrlWithSSES3(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, Http::HeaderValueCollection customizedHeaders, uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); /** * Generate presigned URL with Server Side Encryption(SSE) and with KMS master key id. * if kmsMasterKeyId is empty, we will end up use the default one generated by KMS for you. You can find it via AWS IAM console, it's the one aliased as "aws/s3". * https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html (algo: aws:kms) */ Aws::String GeneratePresignedUrlWithSSEKMS(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, const Aws::String& kmsMasterKeyId = "", uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); /** * Generate presigned URL with Server Side Encryption(SSE) and with KMS master key id. * if kmsMasterKeyId is empty, we will end up use the default one generated by KMS for you. You can find it via AWS IAM console, it's the one aliased as "aws/s3". * https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html (algo: aws:kms) * Headers: "x-amz-server-side-encryption" and "x-amz-server-side-encryption-aws-kms-key-id" will be added internally, don't customize them. */ Aws::String GeneratePresignedUrlWithSSEKMS(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, Http::HeaderValueCollection customizedHeaders, const Aws::String& kmsMasterKeyId = "", uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); /** * Generate presigned URL with Sever Side Encryption(SSE) and with customer supplied Key. * https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html (algo: AES256) */ Aws::String GeneratePresignedUrlWithSSEC(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, const Aws::String& base64EncodedAES256Key, uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); /** * Generate presigned URL with Sever Side Encryption(SSE) and with customer supplied Key. * https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html (algo: AES256) * Headers: "x-amz-server-side-encryption-customer-algorithm","x-amz-server-side-encryption-customer-key" and "x-amz-server-side-encryption-customer-key-MD5" will be added internally, don't customize them. */ Aws::String GeneratePresignedUrlWithSSEC(const Aws::String& bucket, const Aws::String& key, Aws::Http::HttpMethod method, Http::HeaderValueCollection customizedHeaders, const Aws::String& base64EncodedAES256Key, uint64_t expirationInSeconds = MAX_EXPIRATION_SECONDS); virtual bool MultipartUploadSupported() const; void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const S3ClientConfiguration& clientConfiguration); S3ClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace S3 } // namespace Aws