JavaV2: Add presignedURL PUT example that uses query params instead of headers

.doc_gen/metadata/s3_metadata.yaml

@@ -2704,7 +2704,25 @@ s3_Scenario_PresignedUrl:
           github: javav2/example_code/s3
           sdkguide:
           excerpts:
-            - description: Generate a pre-signed URL for an object, then download it (GET request).
+            - description: >-
+                <para>The following shows three example of how to create presigned URLs and use the URLs with
+                  HTTP client libraries:</para>
+                <itemizedlist>
+                  <listitem>
+                    <para>An HTTP GET request that uses the URL with three HTTP client libraries</para>
+                  </listitem>
+                  <listitem>
+                    <para>An HTTP PUT request with metadata in headers that uses the URL with three HTTP client
+                      libraries</para>
+                  </listitem>
+                  <listitem>
+                    <para>An HTTP PUT request with query parameters that uses the URL with one HTTP client
+                      library</para>
+                  </listitem>
+                </itemizedlist>
+                <para>
+                  <emphasis role="bold">Generate a pre-signed URL for an object, then download it (GET request).</emphasis>
+                </para>
             - description: Imports.
               snippet_tags:
                 - presigned.java2.generatepresignedgeturlandretrieve.import
@@ -2722,7 +2740,7 @@ s3_Scenario_PresignedUrl:
               snippet_tags:
                 - presigned.java2.generatepresignedgeturlandretrieve.sdkhttpclient
 
-            - description: Generate a pre-signed URL for an upload, then upload a file (PUT request).
+            - description: <emphasis role="bold">Generate a pre-signed URL with metadata in headers for an upload, then upload a file (PUT request).</emphasis>
             - description: Imports.
               snippet_tags:
                 - presigned.java2.generatepresignedurlandputfilewithmetadata.import
@@ -2739,6 +2757,17 @@ s3_Scenario_PresignedUrl:
             - description: Use the &AWS; for Java V2 <code>SdkHttpClient</code> class to do the upload.
               snippet_tags:
                 - presigned.java2.generatepresignedurlandputfilewithmetadata.sdkhttpclient
+
+            - description: <emphasis role="bold">Generate a pre-signed URL with query parameters for an upload, then upload a file (PUT request).</emphasis>
+            - description: Imports.
+              snippet_tags:
+                - presigned.java2.generatepresignedurlandputfilewithqueryparams.import
+            - description: Generate the URL.
+              snippet_tags:
+                - presigned.java2.generatepresignedurlandputfilewithqueryparams.createpresignedurl
+            - description: Use the &AWS; for Java V2 <code>SdkHttpClient</code> class to do the upload.
+              snippet_tags:
+                - presigned.java2.generatepresignedurlandputfilewithqueryparams.sdkhttpclient
     Python:
       versions:
         - sdk_version: 3

javav2/example_code/s3/README.md

@@ -98,7 +98,8 @@ functions within the same service.
 
 <!--custom.examples.start-->
 - [Create a presigned URL for download](src/main/java/com/example/s3/GeneratePresignedGetUrlAndRetrieve.java)
-- [Create a presigned URL for upload](src/main/java/com/example/s3/GeneratePresignedUrlAndPutFileWithMetadata.java)
+- [Create a presigned URL with metadata in headers for upload](src/main/java/com/example/s3/GeneratePresignedUrlAndPutFileWithMetadata.java)
+- [Create a presigned URL with query parameters for upload](src/main/java/com/example/s3/GeneratePresignedUrlAndPutFileWithQueryParams.java)
 <!--custom.examples.end-->
 
 ## Run the examples

javav2/example_code/s3/src/main/java/com/example/s3/GeneratePresignedUrlAndPutFileWithQueryParams.java

@@ -0,0 +1,158 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.example.s3;
+
+// snippet-start:[presigned.java2.generatepresignedurlandputfilewithqueryparams.import]
+import com.example.s3.util.PresignUrlUtils;
+import org.slf4j.Logger;
+import software.amazon.awssdk.awscore.AwsRequestOverrideConfiguration;
+import software.amazon.awssdk.core.internal.sync.FileContentStreamProvider;
+import software.amazon.awssdk.http.HttpExecuteRequest;
+import software.amazon.awssdk.http.HttpExecuteResponse;
+import software.amazon.awssdk.http.SdkHttpClient;
+import software.amazon.awssdk.http.SdkHttpMethod;
+import software.amazon.awssdk.http.SdkHttpRequest;
+import software.amazon.awssdk.http.apache.ApacheHttpClient;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.PutObjectRequest;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest;
+import software.amazon.awssdk.services.s3.presigner.model.PutObjectPresignRequest;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Paths;
+import java.time.Duration;
+import java.util.Map;
+import java.util.UUID;
+// snippet-end:[presigned.java2.generatepresignedurlandputfilewithqueryparams.import]
+
+/**
+ * Before running this Java V2 code example, set up your development environment.
+ * <p>
+ * For more information, see the following documentation topic:
+ * <p>
+ * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
+ */
+
+public class GeneratePresignedUrlAndPutFileWithQueryParams {
+    private static final Logger logger = org.slf4j.LoggerFactory.getLogger(GeneratePresignedUrlAndPutFileWithQueryParams.class);
+    private final static S3Client s3Client = S3Client.create();
+
+    public static void main(String[] args) {
+        String bucketName = "amzn-s3-demo-bucket" + UUID.randomUUID(); // Change bucket name.
+        String keyName = "key" + UUID.randomUUID();
+        String resourcePath = "uploadDirectory/file1.txt";
+        // Uncomment the following two lines and comment out the previous two lines to use an image file instead of a PDF file.
+        //String resourcePath = "image.png";
+        //String contentType = "image/png";
+
+        Map<String, String> queryParams = Map.of(
+                "x-amz-meta-author", "Bob",
+                "x-amz-meta-version", "1.0.0.0",
+                "x-amz-acl", "private",
+                "x-amz-server-side-encryption", "AES256"
+        );
+
+        PresignUrlUtils.createBucket(bucketName, s3Client);
+        GeneratePresignedUrlAndPutFileWithQueryParams presign = new GeneratePresignedUrlAndPutFileWithQueryParams();
+        try {
+            String presignedUrlString = presign.createPresignedUrl(bucketName, keyName, queryParams);
+            presign.useSdkHttpClientToPut(presignedUrlString, getFileForForClasspathResource(resourcePath));
+
+        } finally {
+            PresignUrlUtils.deleteObject(bucketName, keyName, s3Client);
+            PresignUrlUtils.deleteBucket(bucketName, s3Client);
+        }
+    }
+
+    // snippet-start:[presigned.java2.generatepresignedurlandputfilewithqueryparams.main]
+    // snippet-start:[presigned.java2.generatepresignedurlandputfilewithqueryparams.createpresignedurl]
+    /**
+     *  Creates a presigned URL to use in a subsequent HTTP PUT request. The code adds query parameters
+     *  to the request instead of using headers. By using query parameters, you do not need to add the
+     *  the parameters as headers when the PUT request is eventually sent.
+     *
+     * @param bucketName Bucket name where the object will be uploaded.
+     * @param keyName Key name of the object that will be uploaded.
+     * @param queryParams Query string parameters to be added to the presigned URL.
+     * @return
+     */
+    public String createPresignedUrl(String bucketName, String keyName, Map<String, String> queryParams) {
+        try (S3Presigner presigner = S3Presigner.create()) {
+            // Create an override configuration to store the query parameters.
+            AwsRequestOverrideConfiguration.Builder overrideConfigurationBuilder = AwsRequestOverrideConfiguration.builder();
+
+            queryParams.forEach(overrideConfigurationBuilder::putRawQueryParameter);
+
+            PutObjectRequest objectRequest = PutObjectRequest.builder()
+                    .bucket(bucketName)
+                    .key(keyName)
+                    .overrideConfiguration(overrideConfigurationBuilder.build()) // Add the override configuration.
+                    .build();
+
+            PutObjectPresignRequest presignRequest = PutObjectPresignRequest.builder()
+                    .signatureDuration(Duration.ofMinutes(10))  // The URL expires in 10 minutes.
+                    .putObjectRequest(objectRequest)
+                    .build();
+
+
+            PresignedPutObjectRequest presignedRequest = presigner.presignPutObject(presignRequest);
+            String myURL = presignedRequest.url().toString();
+            logger.info("Presigned URL to upload a file to: [{}]", myURL);
+            logger.info("HTTP method: [{}]", presignedRequest.httpRequest().method());
+
+            return presignedRequest.url().toExternalForm();
+        }
+    }
+    // snippet-end:[presigned.java2.generatepresignedurlandputfilewithqueryparams.createpresignedurl]
+
+    // snippet-start:[presigned.java2.generatepresignedurlandputfilewithqueryparams.sdkhttpclient]
+    /**
+     * Use the AWS SDK for Java V2 SdkHttpClient class to execute the PUT request. Since the
+     * URL contains the query parameters, no headers are needed for metadata, SSE settings, or ACL settings.
+     *
+     * @param presignedUrlString The URL for the PUT request.
+     * @param fileToPut File to uplaod
+     */
+    public void useSdkHttpClientToPut(String presignedUrlString, File fileToPut) {
+        logger.info("Begin [{}] upload", fileToPut.toString());
+
+        try {
+            URL presignedUrl = new URL(presignedUrlString);
+
+            SdkHttpRequest.Builder requestBuilder = SdkHttpRequest.builder()
+                    .method(SdkHttpMethod.PUT)
+                    .uri(presignedUrl.toURI());
+
+            SdkHttpRequest request = requestBuilder.build();
+
+            HttpExecuteRequest executeRequest = HttpExecuteRequest.builder()
+                    .request(request)
+                    .contentStreamProvider(new FileContentStreamProvider(fileToPut.toPath()))
+                    .build();
+
+            try (SdkHttpClient sdkHttpClient = ApacheHttpClient.create()) {
+                HttpExecuteResponse response = sdkHttpClient.prepareRequest(executeRequest).call();
+                logger.info("Response code: {}", response.httpResponse().statusCode());
+            }
+        } catch (URISyntaxException | IOException e) {
+            logger.error(e.getMessage(), e);
+        }
+    }
+    // snippet-end:[presigned.java2.generatepresignedurlandputfilewithqueryparams.sdkhttpclient]
+    // snippet-end:[presigned.java2.generatepresignedurlandputfilewithqueryparams.main]
+
+    public static File getFileForForClasspathResource(String resourcePath) {
+        try {
+            URL resource = GeneratePresignedUrlAndUploadObject.class.getClassLoader().getResource(resourcePath);
+            return Paths.get(resource.toURI()).toFile();
+        } catch (URISyntaxException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+}

javav2/example_code/s3/src/test/java/com/example/s3/presignurl/GeneratePresignedPutUrlTests.java

@@ -4,6 +4,7 @@
 package com.example.s3.presignurl;
 
 import com.example.s3.GeneratePresignedUrlAndPutFileWithMetadata;
+import com.example.s3.GeneratePresignedUrlAndPutFileWithQueryParams;
 import com.example.s3.GeneratePresignedUrlAndUploadObject;
 import com.example.s3.util.PresignUrlUtils;
 import org.junit.jupiter.api.AfterAll;
@@ -16,14 +17,19 @@
 
 import java.io.File;
 import java.net.URL;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 
 class GeneratePresignedPutUrlTests {
     private static final String BUCKET_NAME = "b-" + UUID.randomUUID();
     private static final String KEY_NAME = "k-" + UUID.randomUUID();
     private static final S3Client s3Client = S3Client.create();
-    private static final Map<String, String> METADATA = Map.of("meta1", "value1");
+    private static final String METADATA_KEY = "meta1";
+    private static final String METADATA_VALUE = "value1";
+    private static final Map<String, String> METADATA = Map.of(METADATA_KEY, METADATA_VALUE);
     private static final File PDF_FILE = GeneratePresignedUrlAndPutFileWithMetadata
             .getFileForForClasspathResource("multipartUploadFiles/s3-userguide.pdf");
 
@@ -51,13 +57,63 @@ void testCreatePresignedUrlForPutString() {
         Assertions.assertTrue(objectExists());
     }
 
+    @Test
+    @Tag("IntegrationTest")
+    void test_create_presigned_url_using_query_params_does_not_add_to_signed_headers() {
+        Map<String, String> queryParams = Map.of(
+                "x-amz-meta-author", "Bob",
+                "x-amz-meta-version", "1.0.0.0",
+                "x-amz-acl", "private",
+                "x-amz-server-side-encryption", "AES256"
+        );
+
+        GeneratePresignedUrlAndPutFileWithQueryParams presign = new GeneratePresignedUrlAndPutFileWithQueryParams();
+        String presignedUrl = presign.createPresignedUrl(BUCKET_NAME,  KEY_NAME, queryParams);
+
+        Map<String, String> queryStringMap = parseQueryString(presignedUrl);
+        Assertions.assertFalse(queryStringMap.get("X-Amz-SignedHeaders").contains("x-amz-meta-author"));
+        Assertions.assertFalse(queryStringMap.get("X-Amz-SignedHeaders").contains("x-amz-server-side-encryption"));
+    }
+
+    @Test
+    @Tag("IntegrationTest")
+    void test_create_presigned_url_using_query_params_works() {
+        Map<String, String> queryParams = Map.of(
+                "x-amz-meta-author", "Bob",
+                "x-amz-meta-version", "1.0.0.0",
+                "x-amz-server-side-encryption", "AES256"
+        );
+
+        GeneratePresignedUrlAndPutFileWithQueryParams classUnderTest = new GeneratePresignedUrlAndPutFileWithQueryParams();
+        String presignedUrl = classUnderTest.createPresignedUrl(BUCKET_NAME, KEY_NAME, queryParams);
+
+        classUnderTest.useSdkHttpClientToPut(presignedUrl, PDF_FILE);
+
+        try (S3Client s3Client = S3Client.create()){
+            s3Client.getObject(builder -> {
+                builder.bucket(BUCKET_NAME);
+                builder.key(KEY_NAME);
+                builder.build();
+            }, (response, stream) -> {
+                stream.abort();
+                Assertions.assertEquals("Bob", response.metadata().get("author"));
+                Assertions.assertEquals("1.0.0.0", response.metadata().get("version"));
+                Assertions.assertEquals("AES256", response.serverSideEncryptionAsString());
+                return null;
+            });
+        }
+    }
+
     @Test
     @Tag("IntegrationTest")
     void testCreatePresignedUrlForPut() {
         GeneratePresignedUrlAndPutFileWithMetadata presignInstanceUnderTest = new GeneratePresignedUrlAndPutFileWithMetadata();
 
         final String presignedUrlString = presignInstanceUnderTest.createPresignedUrl(BUCKET_NAME, KEY_NAME, METADATA);
-        Assertions.assertTrue(presignedUrlString.contains("meta1"));
+        final Map<String, String> queryParamsMap = parseQueryString(presignedUrlString);
+        // Assert that the metadata key, but not the value, is in the signed headers.
+        Assertions.assertTrue(queryParamsMap.get("X-Amz-SignedHeaders").contains("x-amz-meta-" + METADATA_KEY));
+        Assertions.assertFalse(queryParamsMap.get("X-Amz-SignedHeaders").contains("x-amz-meta-" + METADATA_VALUE));
     }
 
     @Test
@@ -106,4 +162,47 @@ private static Boolean objectHasMetadata() {
         // The SDK strips off the leading "x-amz-meta-" from the metadata key.
         return response.metadata().get("meta1").equals(GeneratePresignedPutUrlTests.METADATA.get("meta1"));
     }
+
+    public static Map<String, String> parseQueryString(String queryString) {
+        Map<String, String> params = new HashMap<>();
+
+        // Return empty map for null or empty input
+        if (queryString == null || queryString.isEmpty()) {
+            return params;
+        }
+
+        // Split the query string into key-value pairs
+        String[] pairs = queryString.split("&");
+
+        for (String pair : pairs) {
+            // Find the separator between key and value
+            int separatorIndex = pair.indexOf("=");
+
+            // Handle key-only parameters (no value)
+            if (separatorIndex <= 0) {
+                params.put(URLDecoder.decode(pair, StandardCharsets.UTF_8), null);
+                continue;
+            }
+
+            // Extract and decode the key
+            String key = URLDecoder.decode(
+                    pair.substring(0, separatorIndex),
+                    StandardCharsets.UTF_8
+            );
+
+            // Extract and decode the value if it exists
+            String value = null;
+            if (pair.length() > separatorIndex + 1) {
+                value = URLDecoder.decode(
+                        pair.substring(separatorIndex + 1),
+                        StandardCharsets.UTF_8
+                );
+            }
+
+            params.put(key, value);
+        }
+
+        return params;
+    }
+
 }