/** * 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; typedef S3ClientConfiguration ClientConfigurationType; typedef S3EndpointProvider EndpointProviderType; /** * 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. A request could fail after * the initial 200 OK response has been sent. This means that a 200 OK * response can contain either a success or an error. If you call the S3 API * directly, make sure to design your application to parse the contents of the * response and handle it appropriately. If you use Amazon Web Services SDKs, SDKs * handle this condition. The SDKs detect the embedded error and apply error * handling per your configuration settings (including automatically retrying the * request as appropriate). If the condition persists, the SDKs throws an exception * (or, for the SDKs that don't use exceptions, they return the error).

*

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. If you call the S3 API directly, make sure * to design your application to parse the contents of the response and handle it * appropriately. If you use Amazon Web Services SDKs, SDKs handle this condition. * The SDKs detect the embedded error and apply error handling per your * configuration settings (including automatically retrying the request as * appropriate). If the condition persists, the SDKs throws an exception (or, for * the SDKs that don't use exceptions, they return the error).

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. The request can also result in a data retrieval charge for the source if * the source storage class bills for data retrieval. 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 (the default) or specify new metadata. * However, the access control list (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-website-redirect-location is unique to each object and must * be specified in the request headers to copy the value.

*
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

Amazon S3 * automatically encrypts all new objects that are copied to an S3 bucket. When * copying an object, if you don't specify encryption information in your copy * request, the encryption setting of the target object is set to the default * encryption configuration of the destination bucket. By default, all buckets have * a base level of encryption configuration that uses server-side encryption with * Amazon S3 managed keys (SSE-S3). If the destination bucket has a default * encryption configuration that uses server-side encryption with Key Management * Service (KMS) keys (SSE-KMS), dual-layer server-side encryption with Amazon Web * Services KMS keys (DSSE-KMS), or server-side encryption with customer-provided * encryption keys (SSE-C), Amazon S3 uses the corresponding KMS key, or a * customer-provided key to encrypt the target object copy.

When you perform * a CopyObject operation, if you want to use a different type of * encryption setting for the target object, you can use other appropriate * encryption-related headers to encrypt the target object with a KMS key, an * Amazon S3 managed key, or a customer-provided key. With server-side encryption, * Amazon S3 encrypts your data as it writes your data to disks in its data centers * and decrypts the data when you access it. If the encryption setting in your * request is different from the default encryption configuration of the * destination bucket, the encryption setting in your request takes precedence. If * the source object for the copy is stored in Amazon S3 using SSE-C, you must * provide the necessary encryption information in your request so that Amazon S3 * can decrypt the object for copying. 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 that are 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 can 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 by using the * StorageClass parameter. For more information, see Storage * Classes in the Amazon S3 User Guide.

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. * For more information, see Copying * Objects.

Versioning

By default, * x-amz-copy-source header 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.

The following operations * are related to CopyObject:

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. */ virtual Model::CopyObjectOutcomeCallable CopyObjectCallable(const Model::CopyObjectRequest& request) const; /** * An Async wrapper for CopyObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CopyObjectAsync(const Model::CopyObjectRequest& request, const CopyObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

Permissions

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

    *

  • Access control lists (ACLs) - If your CreateBucket * request specifies access control list (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 for the * CreateBucket request is private or if the request 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 x-amz-object-ownership header, then the * s3:PutBucketOwnershipControls permission is required. By default, * ObjectOwnership is set to BucketOWnerEnforced and ACLs * are disabled. We recommend keeping ACLs disabled, except in uncommon use cases * where you must control access for each object individually. If you want to * change the ObjectOwnership setting, you can use the * x-amz-object-ownership header in your CreateBucket * request to set the ObjectOwnership setting of your choice. For more * information about S3 Object Ownership, see Controlling * object ownership in the Amazon S3 User Guide.

  • * S3 Block Public Access - If your specific use case requires granting * public access to your S3 resources, you can disable Block Public Access. You can * create a new bucket with Block Public Access enabled, then separately call the * * DeletePublicAccessBlock API. To use this operation, you must * have the s3:PutBucketPublicAccessBlock permission. By default, all * Block Public Access settings are enabled for new buckets. To avoid inadvertent * exposure of your resources, we recommend keeping the S3 Block Public Access * settings enabled. For more information about S3 Block Public Access, see Blocking * public access to your Amazon S3 storage in the Amazon S3 User Guide. *

If your CreateBucket * request sets BucketOwnerEnforced for Amazon 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 Setting * Object Ownership on an existing bucket in the Amazon S3 User Guide. *

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 Configuration.

*

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. *

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. Amazon S3 automatically encrypts all new objects that are * uploaded to an S3 bucket. When doing a multipart upload, if you don't specify * encryption information in your request, the encryption setting of the uploaded * parts is set to the default encryption configuration of the destination bucket. * By default, all buckets have a base level of encryption configuration that uses * server-side encryption with Amazon S3 managed keys (SSE-S3). If the destination * bucket has a default encryption configuration that uses server-side encryption * with an Key Management Service (KMS) key (SSE-KMS), or a customer-provided * encryption key (SSE-C), Amazon S3 uses the corresponding KMS key, or a * customer-provided key to encrypt the uploaded parts. When you perform a * CreateMultipartUpload operation, if you want to use a different type of * encryption setting for the uploaded parts, you can request that Amazon S3 * encrypts the object with a KMS key, an Amazon S3 managed key, or a * customer-provided key. If the encryption setting in your request is different * from the default encryption configuration of the destination bucket, the * encryption setting in your request takes precedence. 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. You can request that Amazon S3 save * the uploaded parts encrypted with server-side encryption with an Amazon S3 * managed key (SSE-S3), an Key Management Service (KMS) key (SSE-KMS), or a * customer-provided encryption key (SSE-C).

To perform a multipart upload * with encryption by 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 and Protecting * data using server-side encryption with Amazon Web Services KMS 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

Amazon S3 * encrypts data by using server-side encryption with an Amazon S3 managed key * (SSE-S3) by default. 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. You can request that Amazon S3 encrypts data at * rest by using server-side encryption with other key options. The option you use * depends on whether you want to use KMS keys (SSE-KMS) or provide your own * encryption keys (SSE-C).

  • Use KMS keys (SSE-KMS) that include * the Amazon Web Services managed key (aws/s3) and KMS customer * managed keys stored in Key Management Service (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 (aws/s3 key) in KMS to protect the * data.

    All GET and PUT * requests for an object protected by KMS fail if you don't make them by using * Secure Sockets Layer (SSL), Transport Layer Security (TLS), or Signature Version * 4.

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

  • Use * customer-provided encryption keys (SSE-C) – 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 customer-provided * encryption keys (SSE-C), see * Protecting data using server-side encryption with customer-provided encryption * keys (SSE-C).

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.

The following operations are related to * DeleteBucket:

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 resets the default encryption for * the bucket as server-side encryption with Amazon S3 managed keys (SSE-S3). For * information about the bucket default encryption feature, see Amazon * S3 Bucket Default 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.

The following operations are related to * DeleteBucketEncryption:

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.

To ensure that bucket owners don't * inadvertently lock themselves out of their own buckets, the root principal in a * bucket owner's Amazon Web Services account can perform the * GetBucketPolicy, PutBucketPolicy, and * DeleteBucketPolicy API actions, even if their bucket policy * explicitly denies the root principal's access. Bucket owner root principals can * only be blocked from performing these API actions by VPC endpoint policies and * Amazon Web Services Organizations policies.

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 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 DeleteObjectTagging:

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.

The following operations * are related to GetBucketAccelerateConfiguration:

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.

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

To use this API operation against an Object Lambda access point, * provide the alias of the Object Lambda access point in place of the bucket name. * If the Object Lambda access point alias in a request is not valid, the error * code InvalidAccessPointAliasError is returned. For more information * about InvalidAccessPointAliasError, see List * of Error Codes.

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 * GetBucketAcl:

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.

The following operations are related to * GetBucketAnalyticsConfiguration:

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.

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

To use this API operation against an Object Lambda access * point, provide the alias of the Object Lambda access point in place of the * bucket name. If the Object Lambda access point alias in a request is not valid, * the error code InvalidAccessPointAliasError is returned. For more * information about InvalidAccessPointAliasError, see List * of Error Codes.

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. By * default, all buckets have a default encryption configuration that uses * server-side encryption with Amazon S3 managed keys (SSE-S3). For information * about the bucket default encryption feature, see Amazon * S3 Bucket Default Encryption in the Amazon S3 User Guide.

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 API operation against an access point, provide the alias of the * access point in place of the bucket name.

To use this API operation * against an Object Lambda access point, provide the alias of the Object Lambda * access point in place of the bucket name. If the Object Lambda access point * alias in a request is not valid, the error code * InvalidAccessPointAliasError is returned. For more information * about InvalidAccessPointAliasError, see List * of Error Codes.

We recommend that you use HeadBucket * to return the Region that a bucket resides in. For backward compatibility, * Amazon S3 continues to support GetBucketLocation.

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.

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.

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

To use this * API operation against an Object Lambda access point, provide the alias of the * Object Lambda access point in place of the bucket name. If the Object Lambda * access point alias in a request is not valid, the error code * InvalidAccessPointAliasError is returned. For more information * about InvalidAccessPointAliasError, see List * of Error Codes.

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.

To ensure that bucket owners don't inadvertently lock * themselves out of their own buckets, the root principal in a bucket owner's * Amazon Web Services account can perform the GetBucketPolicy, * PutBucketPolicy, and DeleteBucketPolicy API actions, * even if their bucket policy explicitly denies the root principal's access. * Bucket owner root principals can only be blocked from performing these API * actions by VPC endpoint policies and Amazon Web Services Organizations * policies.

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

To use * this API operation against an Object Lambda access point, provide the alias of * the Object Lambda access point in place of the bucket name. If the Object Lambda * access point alias in a request is not valid, the error code * InvalidAccessPointAliasError is returned. For more information * about InvalidAccessPointAliasError, see List * of Error Codes.

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 GetBucketWebsite:

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 Flexible * Retrieval 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 InvalidObjectState 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 Key Management Service (KMS) * keys (SSE-KMS), dual-layer server-side encryption with Amazon Web Services KMS * keys (DSSE-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.

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 that you request doesn’t exist, the * error that 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) error.

If you don’t have the * s3:ListBucket permission, Amazon S3 returns 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 you request the current version without * a specific version ID, only s3:GetObject permission is required. * s3:GetObjectVersion permission won't be required.

  • *

    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

Overriding * Response Header Values

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.

*

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 * 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 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.

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 400 Bad Request, 403 Forbidden or 404 * Not Found 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 * operation 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.

To use this API operation against an Object Lambda * access point, provide the alias of the Object Lambda access point in place of * the bucket name. If the Object Lambda access point alias in a request is not * valid, the error code InvalidAccessPointAliasError is returned. For * more information about InvalidAccessPointAliasError, see List * of Error Codes.

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 * 400 Bad Request, 403 Forbidden or 404 Not * Found 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 Key Management Service (KMS) keys (SSE-KMS), dual-layer * server-side encryption with Amazon Web Services KMS keys (DSSE-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.

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 Actions, * resources, and condition keys for Amazon S3. If the object you request * doesn't exist, the error that 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 error.

  • If you don’t have the * s3:ListBucket permission, Amazon S3 returns an HTTP status code 403 * 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.

For information about * Amazon S3 buckets, see Creating, * configuring, and working with Amazon S3 buckets.

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 permission 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 in the Amazon S3 User Guide.

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 * permission 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 in the Amazon S3 User * Guide.

This section describes the latest revision of this * action. We recommend that you use this revised API operation for application * development. For backward compatibility, Amazon S3 continues to support the * prior version of this API operation, 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.

*
Permissions

You can set access permissions by 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>&</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.

    *

The following operations are related to * PutBucketAcl:

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.

* PutBucketAnalyticsConfiguration has the following 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.

The following operations are related * to PutBucketAnalyticsConfiguration:

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.

The * following operations are related to PutBucketCors:

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 Keys for an existing bucket.

By default, * all buckets have a default encryption configuration that uses server-side * encryption with Amazon S3 managed keys (SSE-S3). You can optionally configure * default encryption for a bucket by using server-side encryption with Key * Management Service (KMS) keys (SSE-KMS), dual-layer server-side encryption with * Amazon Web Services KMS keys (DSSE-KMS), or server-side encryption with * customer-provided keys (SSE-C). If you specify default encryption by using * SSE-KMS, you can also configure Amazon S3 Bucket Keys. For information about * bucket default encryption, see Amazon * S3 bucket default 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 permission 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.

The following operations are related to * PutBucketEncryption:

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.

PutBucketIntelligentTieringConfiguration has * the following 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

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.

*
Permissions

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

The s3:PutInventoryConfiguration permission allows * a user to create an S3 * Inventory report that includes all object metadata fields available and to * specify the destination bucket to store the inventory. A user with read access * to objects in the destination bucket can also access all object metadata fields * that are available in the inventory report.

To restrict access to an * inventory report, see Restricting * access to an Amazon S3 Inventory report in the Amazon S3 User Guide. * For more information about the metadata fields available in S3 Inventory, see Amazon * S3 Inventory lists in the Amazon S3 User Guide. For more information * about permissions, see Permissions * related to bucket subresource operations and Identity * and access management in Amazon S3 in the Amazon S3 User Guide.

*

PutBucketInventoryConfiguration has the following * 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

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.

The following operations are * related to PutBucketInventoryConfiguration:

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:

*

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

  • A status indicating 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. An 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 operations 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 (by 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 GETObjectAcl 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:

PutBucketMetricsConfiguration 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 the required 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.

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.

To ensure that * bucket owners don't inadvertently lock themselves out of their own buckets, the * root principal in a bucket owner's Amazon Web Services account can perform the * GetBucketPolicy, PutBucketPolicy, and * DeleteBucketPolicy API actions, even if their bucket policy * explicitly denies the root principal's access. Bucket owner root principals can * only be blocked from performing these API actions by VPC endpoint policies and * Amazon Web Services Organizations policies.

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 * configuration 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 configuration 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.

The following operations are related to * PutBucketVersioning:

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. You * cannot use PutObject to only update a single piece of metadata for * an existing object. You must put the entire object with updated metadata if you * want to update some values.

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. To prevent objects from being * deleted or overwritten, you can use Amazon * S3 Object Lock.

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.

  • To * successfully set the tag-set with your PutObject request, you must * have the s3:PutObjectTagging 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.

*

You have four mutually exclusive options to protect data using * server-side encryption in Amazon S3, depending on how you choose to manage the * encryption keys. Specifically, the encryption key options are Amazon S3 managed * keys (SSE-S3), Amazon Web Services KMS keys (SSE-KMS or DSSE-KMS), and * customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side * encryption by using Amazon S3 managed keys (SSE-S3) by default. You can * optionally tell Amazon S3 to encrypt data at rest by using server-side * encryption with other key options. For more information, see Using * Server-Side Encryption.

When adding a new object, you can use headers * to grant ACL-based 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. By default, all objects are private. Only the owner has full * access control. 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.

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.

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. *

For more information about related Amazon S3 APIs, see the * following:

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.

*
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.

The following operations are related to * PutObjectAcl:

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.

PutObjectTagging has the following 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.

The following operations are * related to PutObjectTagging:

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".

The following operations are related to * PutPublicAccessBlock:

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

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 *

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 * configuration.

  • You can issue more than one select request on * the same Amazon S3 object. Amazon S3 doesn't duplicate 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.

*
Permissions

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.

Restoring objects

Objects that you archive * to the S3 Glacier Flexible Retrieval Flexible Retrieval 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 the S3 Glacier Flexible Retrieval Flexible Retrieval 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. If you want a * permanent copy of the object, create a copy of it in the Amazon S3 Standard * storage class in your S3 bucket. To access an archived object, you must restore * the object for the duration (number of days) that you specify. For objects in * the Archive Access or Deep Archive Access tiers of S3 Intelligent-Tiering, you * must first initiate a restore request, and then wait until the object is moved * into the Frequent Access tier.

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, 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 * Flexible Retrieval Flexible Retrieval storage class or S3 Intelligent-Tiering * Archive tier when occasional urgent requests for restoring 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 Flexible Retrieval * Flexible Retrieval 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 free for objects stored in the S3 * Glacier Flexible Retrieval and S3 Intelligent-Tiering storage classes, enabling * you to retrieve large amounts, even petabytes, of data at no cost. Bulk * retrievals typically finish within 5–12 hours for objects stored in the S3 * Glacier Flexible Retrieval Flexible Retrieval storage class or S3 * Intelligent-Tiering Archive tier. Bulk retrievals are also the lowest-cost * retrieval option when restoring objects from S3 Glacier Deep Archive. They * typically finish within 48 hours for objects stored in the S3 Glacier Deep * Archive storage class or S3 Intelligent-Tiering Deep Archive tier.

    • *

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

*

The following operations are related to RestoreObject:

*

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.

*
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 * 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.

  • The GLACIER, * DEEP_ARCHIVE, and REDUCED_REDUNDANCY storage classes, * or the ARCHIVE_ACCESS and DEEP_ARCHIVE_ACCESS access * tiers of the INTELLIGENT_TIERING storage class: You cannot query * objects in the GLACIER, DEEP_ARCHIVE, or * REDUCED_REDUNDANCY storage classes, nor objects in the * ARCHIVE_ACCESS or DEEP_ARCHIVE_ACCESS access tiers of * the INTELLIGENT_TIERING storage class. For more information about * storage classes, see Using * Amazon S3 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

The following * operations are related to SelectObjectContent:

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.

*

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. You have three mutually exclusive options to protect data using * server-side encryption in Amazon S3, depending on how you choose to manage the * encryption keys. Specifically, the encryption key options are Amazon S3 managed * keys (SSE-S3), Amazon Web Services KMS keys (SSE-KMS), and Customer-Provided * Keys (SSE-C). Amazon S3 encrypts data with server-side encryption using Amazon * S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to * encrypt data at rest using server-side encryption with other key options. The * option you use depends on whether you want to use KMS keys (SSE-KMS) or provide * your own encryption key (SSE-C). 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 (SSE-C), 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 (SSE-C) 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

* UploadPart has the following 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

The following operations are * related to UploadPart:

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

      *

The following operations are related to * UploadPartCopy:

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