Periodic update - 2023-03-06

Author: aws-alan

doc_source/DeletingObjects.md

@@ -5,28 +5,28 @@ You can delete one or more objects directly from Amazon S3 using the Amazon S3 c
 For information about Amazon S3 features and pricing, see [Amazon S3 pricing](http://aws.amazon.com/s3/pricing)\.
 
 You have the following API options when deleting an object: 
-+ **Delete a single object —** Amazon S3 provides the DELETE API that you can use to delete one object in a single HTTP request\. 
-+ **Delete multiple objects —** Amazon S3 provides the Multi\-Object Delete API that you can use to delete up to 1,000 objects in a single HTTP request\. 
++ **Delete a single object** – Amazon S3 provides the `DELETE` \(`DeleteObject`\) API operation that you can use to delete one object in a single HTTP request\. 
++ **Delete multiple objects** – Amazon S3 provides the Multi\-Object Delete \(`DeleteObjects`\) API operation that you can use to delete up to 1,000 objects in a single HTTP request\. 
 
 When deleting objects from a bucket that is not version\-enabled, you provide only the object key name\. However, when deleting objects from a version\-enabled bucket, you can optionally provide the version ID of the object to delete a specific version of the object\. 
 
 ## Programmatically deleting objects from a version\-enabled bucket<a name="DeletingObjectsfromaVersion-EnabledBucket"></a>
 
-If your bucket is version\-enabled, multiple versions of the same object can exist in the bucket\. When working with version\-enabled buckets, the delete API enables the following options:
-+ **Specify a non\-versioned delete request —** Specify only the object's key, and not the version ID\. In this case, Amazon S3 creates a delete marker and returns its version ID in the response\. This makes your object disappear from the bucket\. For information about object versioning and the delete marker concept, see [Using versioning in S3 buckets](Versioning.md)\.
-+ **Specify a versioned delete request —** Specify both the key and also a version ID\. In this case the following two outcomes are possible:
+If your bucket is version\-enabled, multiple versions of the same object can exist in the bucket\. When working with version\-enabled buckets, the delete API operations enable the following options:
++ **Specify a non\-versioned delete request** – Specify only the object's key, and not the version ID\. In this case, Amazon S3 creates a delete marker and returns its version ID in the response\. This makes your object disappear from the bucket\. For information about object versioning and the delete marker concept, see [Using versioning in S3 buckets](Versioning.md)\.
++ **Specify a versioned delete request** – Specify both the key and also a version ID\. In this case the following two outcomes are possible:
   + If the version ID maps to a specific object version, Amazon S3 deletes the specific version of the object\.
   + If the version ID maps to the delete marker of that object, Amazon S3 deletes the delete marker\. This makes the object reappear in your bucket\. 
 
 ## Deleting objects from an MFA\-enabled bucket<a name="DeletingObjectsfromanMFA-EnabledBucket"></a>
 
 When deleting objects from a multi\-factor authentication \(MFA\)\-enabled bucket, note the following:
-+ If you provide an invalid MFA token, the request always fails\.
-+ If you have an MFA\-enabled bucket, and you make a versioned delete request \(you provide an object key and version ID\), the request fails if you don't provide a valid MFA token\. In addition, when using the Multi\-Object Delete API on an MFA\-enabled bucket, if any of the deletes are a versioned delete request \(that is, you specify object key and version ID\), the entire request fails if you don't provide an MFA token\. 
++ If you provide an MFA token that isn't valid, the request always fails\.
++ If you have an MFA\-enabled bucket and you make a versioned delete request \(you provide an object key and version ID\), the request fails if you don't provide a valid MFA token\. In addition, when using the Multi\-Object Delete API operation on an MFA\-enabled bucket, if any of the deletes are a versioned delete request \(that is, you specify an object key and version ID\), the entire request fails if you don't provide an MFA token\. 
 
-However, in the following cases the request succeeds:
-+ If you have an MFA\-enabled bucket, and you make a non\-versioned delete request \(you are not deleting a versioned object\),  and you don't provide an MFA token, the delete succeeds\. 
-+ If you have a Multi\-Object Delete request specifying only non\-versioned objects to delete from an MFA\-enabled bucket,  and you don't provide an MFA token, the deletions succeed\.
+However, in the following cases, the request succeeds:
++ If you have an MFA\-enabled bucket and you make a non\-versioned delete request \(you are not deleting a versioned object\),  and you don't provide an MFA token, the delete succeeds\. 
++ If you have a Multi\-Object Delete request that specifies only non\-versioned objects to delete from an MFA\-enabled bucket  and you don't provide an MFA token, the deletions succeed\.
 
 For information about MFA delete, see [Configuring MFA delete](MultiFactorAuthenticationDelete.md)\.
 

doc_source/ListingKeysUsingAPIs.md

@@ -263,79 +263,46 @@ List objects using pagination\.
 ------
 #### [ JavaScript ]
 
-**SDK for JavaScript V3**  
+**SDK for JavaScript \(v3\)**  
  There's more on GitHub\. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/s3#code-examples)\. 
-Create the client\.  
+List all of the objects in your bucket\. If there is more than one object, IsTruncated and NextContinuationToken will be used to iterate over the full list\.  
 
 ```
-// Create service client module using ES6 syntax.
-import { S3Client } from "@aws-sdk/client-s3";
-// Set the AWS Region.
-const REGION = "us-east-1";
-// Create an Amazon S3 service client object.
-const s3Client = new S3Client({ region: REGION });
-export { s3Client };
-```
-List the objects\.  
+import {
+  S3Client,
+  // This command supersedes the ListObjectsCommand and is the recommended way to list objects.
+  ListObjectsV2Command,
+} from "@aws-sdk/client-s3";
 
-```
-// Import required AWS SDK clients and commands for Node.js.
-import { ListObjectsCommand } from "@aws-sdk/client-s3";
-import { s3Client } from "./libs/s3Client.js"; // Helper function that creates an Amazon S3 service client module.
+const client = new S3Client({});
 
-// Create the parameters for the bucket
-export const bucketParams = { Bucket: "BUCKET_NAME" };
+export const main = async () => {
+  const command = new ListObjectsV2Command({
+    Bucket: "my-bucket",
+    // The default and maximum number of keys returned is 1000. This limits it to
+    // one for demonstration purposes.
+    MaxKeys: 1,
+  });
 
-export const run = async () => {
   try {
-    const data = await s3Client.send(new ListObjectsCommand(bucketParams));
-    console.log("Success", data);
-    return data; // For unit tests.
-  } catch (err) {
-    console.log("Error", err);
-  }
-};
-run();
-```
-List 1000 or more objects\.  
+    let isTruncated = true;
 
-```
-// Import required AWS SDK clients and commands for Node.js.
-import { ListObjectsCommand } from "@aws-sdk/client-s3";
-import { s3Client } from "./libs/s3Client.js"; // Helper function that creates an Amazon S3 service client module.
-
-// Create the parameters for the bucket
-export const bucketParams = { Bucket: "BUCKET_NAME" };
-
-export async function run() {
-  // Declare truncated as a flag that the while loop is based on.
-  let truncated = true;
-  // Declare a variable to which the key of the last element is assigned to in the response.
-  let pageMarker;
-  // while loop that runs until 'response.truncated' is false.
-  while (truncated) {
-    try {
-      const response = await s3Client.send(new ListObjectsCommand(bucketParams));
-      // return response; //For unit tests
-      response.Contents.forEach((item) => {
-        console.log(item.Key);
-      });
-      // Log the key of every item in the response to standard output.
-      truncated = response.IsTruncated;
-      // If truncated is true, assign the key of the last element in the response to the pageMarker variable.
-      if (truncated) {
-        pageMarker = response.Contents.slice(-1)[0].Key;
-        // Assign the pageMarker value to bucketParams so that the next iteration starts from the new pageMarker.
-        bucketParams.Marker = pageMarker;
-      }
-      // At end of the list, response.truncated is false, and the function exits the while loop.
-    } catch (err) {
-      console.log("Error", err);
-      truncated = false;
+    console.log("Your bucket contains the following objects:\n")
+    let contents = "";
+
+    while (isTruncated) {
+      const { Contents, IsTruncated, NextContinuationToken } = await client.send(command);
+      const contentsList = Contents.map((c) => ` • ${c.Key}`).join("\n");
+      contents += contentsList + "\n";
+      isTruncated = IsTruncated;
+      command.input.ContinuationToken = NextContinuationToken;
     }
+    console.log(contents);
+
+  } catch (err) {
+    console.error(err);
   }
-}
-run();
+};
 ```
 +  For API details, see [ListObjects](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-s3/classes/listobjectscommand.html) in *AWS SDK for JavaScript API Reference*\. 
 

doc_source/ManagingDelMarkers.md

@@ -2,7 +2,7 @@
 
 ## Configuring lifecycle to clean up expired delete markers automatically<a name="LifecycleDelMarker"></a>
 
-An expired object delete marker is one where all object versions are deleted and only a single delete marker remains\. If the lifecycle policy is set to delete current versions, or the `ExpiredObjectDeleteMarker` action is explicitly set, Amazon S3 removes the expired object’s delete marker\. For an example, see [Example 7: Removing expired object delete markers](lifecycle-configuration-examples.md#lifecycle-config-conceptual-ex7)\. 
+An expired object delete marker is one where all object versions are deleted and only a single delete marker remains\. If the lifecycle configuration is set to delete current versions, or the `ExpiredObjectDeleteMarker` action is explicitly set, Amazon S3 removes the expired object’s delete marker\. For an example, see [Example 7: Removing expired object delete markers](lifecycle-configuration-examples.md#lifecycle-config-conceptual-ex7)\. 
 
 ## Removing delete markers to make an older version current<a name="RemDelMarker"></a>
 

doc_source/OrderOutposts.md

@@ -1,6 +1,6 @@
 # Setting up your Outpost<a name="OrderOutposts"></a>
 
-To get started with Amazon S3 on Outposts, you will need an Outpost with Amazon S3 capacity deployed at your facility\. For information about options for ordering an Outpost and S3 capacity, see [AWS Outposts](http://aws.amazon.com/outposts)\. For specifications and to see how S3 on Outposts is different than Amazon S3, see [How is Amazon S3 on Outposts different from Amazon S3?](S3OnOutpostsRestrictionsLimitations.md)
+To get started with Amazon S3 on Outposts, you will need an Outpost with Amazon S3 capacity deployed at your facility\. For information about options for ordering an Outpost and S3 capacity, see [AWS Outposts](http://aws.amazon.com/outposts)\. To check if your Outposts has S3 capacity on it, you can use the [ListOutpostsWithS3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_s3outposts_ListOutpostsWithS3.html) API call\. For specifications and to see how S3 on Outposts is different than Amazon S3, see [How is Amazon S3 on Outposts different from Amazon S3?](S3OnOutpostsRestrictionsLimitations.md)
 
 For more information, see the following topics\.
 

doc_source/PresignedUrlDelete.md

@@ -5,69 +5,93 @@ The following AWS SDK for JavaScript example uses a presigned URL to delete an o
 For more information about using presigned URLs, see [Using presigned URLs](using-presigned-url.md)\.  
 
 ```
-          // Import the required AWS SDK clients and commands for Node.js
+          import https from "https";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { fromIni } from "@aws-sdk/credential-providers";
+import { HttpRequest } from "@aws-sdk/protocol-http";
 import {
-  CreateBucketCommand,
-  DeleteObjectCommand,
-  PutObjectCommand,
-  DeleteBucketCommand }
-from "@aws-sdk/client-s3";
-import { s3Client } from "./libs/s3Client.js"; // Helper function that creates an Amazon S3 service client module.
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import fetch from "node-fetch";
+  getSignedUrl,
+  S3RequestPresigner,
+} from "@aws-sdk/s3-request-presigner";
+import { parseUrl } from "@aws-sdk/url-parser";
+import { formatUrl } from "@aws-sdk/util-format-url";
+import { Hash } from "@aws-sdk/hash-node";
 
-// Set parameters
-// Create a random name for the Amazon Simple Storage Service (Amazon S3) bucket and key
-export const bucketParams = {
-  Bucket: `test-bucket-${Math.ceil(Math.random() * 10 ** 10)}`,
-  Key: `test-object-${Math.ceil(Math.random() * 10 ** 10)}`,
-  Body: "BODY"
+const createPresignedUrlWithoutClient = async ({ region, bucket, key }) => {
+  const url = parseUrl(`https://${bucket}.s3.${region}.amazonaws.com/${key}`);
+  const presigner = new S3RequestPresigner({
+    credentials: fromIni(),
+    region,
+    sha256: Hash.bind(null, "sha256"),
+  });
+
+  const signedUrlObject = await presigner.presign(
+    new HttpRequest({ ...url, method: "PUT" })
+  );
+  return formatUrl(signedUrlObject);
 };
-export const run = async () => {
-  try {
-    // Create an S3 bucket.
-    console.log(`Creating bucket ${bucketParams.Bucket}`);
-    await s3Client.send(new CreateBucketCommand({ Bucket: bucketParams.Bucket }));
-    console.log(`Waiting for "${bucketParams.Bucket}" bucket creation...`);
-  } catch (err) {
-    console.log("Error creating bucket", err);
-  }
-  try {
-    // Create a command to put the object in the S3 bucket.
-    const command = new PutObjectCommand(bucketParams);
-    // Create the presigned URL.
-    const signedUrl = await getSignedUrl(s3Client, command, {
-      expiresIn: 3600,
-    });
-    console.log(
-      `\nPutting "${bucketParams.Key}" using signedUrl with body "${bucketParams.Body}" in v3`
-    );
-    console.log(signedUrl);
-    const response = await fetch(signedUrl, {method: 'PUT', body: bucketParams.Body});
-    console.log(
-      `\nResponse returned by signed URL: ${await response.text()}\n`
-    );
-  } catch (err) {
-    console.log("Error creating presigned URL", err);
-  }
-  try {
-    // Delete the object.
-    console.log(`\nDeleting object "${bucketParams.Key}"} from bucket`);
-    await s3Client.send(
-      new DeleteObjectCommand({ Bucket: bucketParams.Bucket, Key: bucketParams.Key })
+
+const createPresignedUrlWithClient = async ({ region, bucket, key }) => {
+  const client = new S3Client({ region });
+  const command = new PutObjectCommand({ Bucket: bucket, Key: key });
+  return getSignedUrl(client, command, { expiresIn: 3600 });
+};
+
+function put(url, data) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      url,
+      { method: "PUT", headers: { "Content-Length": new Blob([data]).size } },
+      (res) => {
+        let responseBody = "";
+        res.on("data", (chunk) => {
+          responseBody += chunk;
+        });
+        res.on("end", () => {
+          resolve(responseBody);
+        });
+      }
     );
-  } catch (err) {
-    console.log("Error deleting object", err);
-  }
+    req.on("error", (err) => {
+      reject(err);
+    });
+    req.write(data);
+    req.end();
+  });
+}
+
+export const main = async () => {
+  const REGION = "us-east-1";
+  const BUCKET = "coreys-default-bucket";
+  const KEY = "corey_test.txt";
+
+  // There are two ways to generate a presigned URL.
+  // 1. Use createPresignedUrl without the S3 client.
+  // 2. Use getSignedUrl in conjunction with the S3 client and GetObjectCommand.
   try {
-    // Delete the S3 bucket.
-    console.log(`\nDeleting bucket ${bucketParams.Bucket}`);
-    await s3Client.send(
-      new DeleteBucketCommand({ Bucket: bucketParams.Bucket })
-    );
+    const noClientUrl = await createPresignedUrlWithoutClient({
+      region: REGION,
+      bucket: BUCKET,
+      key: KEY,
+    });
+
+    const clientUrl = await createPresignedUrlWithClient({
+      region: REGION,
+      bucket: BUCKET,
+      key: KEY,
+    });
+
+    // After you get the presigned URL, you can provide your own file
+    // data. Refer to put() above.
+    console.log("Calling PUT using presigned URL without client");
+    await put(noClientUrl, "Hello World");
+
+    console.log("Calling PUT using presigned URL with client");
+    await put(clientUrl, "Hello World");
+
+    console.log("\nDone. Check your S3 console.");
   } catch (err) {
-    console.log("Error deleting bucket", err);
+    console.error(err);
   }
 };
-run();
 ```