S3AsyncClient doesn't respect chunkedEncodingEnabled(false)

[vladykin]

Describe the bug

Some third-party S3 implementations don't support chunked encoding and require setting S3Configuration.builder().chunkedEncodingEnabled(false). Example:
https://www.alibabacloud.com/help/en/oss/developer-reference/use-amazon-s3-sdks-to-access-oss

This config tweak works with S3Client, but is apparently ignored by the S3AsyncClient. Despite having .chunkedEncodingEnabled(false), the S3AsyncClient still uses chunked encoding.

Regression Issue

• Select this option if this issue appears to be a regression.

Expected Behavior

We'd expect S3AsyncClient to behave similarly to S3Client, i.e. stop using chunked encoding when .chunkedEncodingEnabled(false) is specified.

Current Behavior

S3AsyncClient uses chunked encoding despite .chunkedEncodingEnabled(false)

Reproduction Steps

Here's a unit test demonstrating the behavior of both S3Client and S3AsyncClient:

import static com.github.tomakehurst.wiremock.client.WireMock.matching;
import static com.github.tomakehurst.wiremock.client.WireMock.ok;
import static com.github.tomakehurst.wiremock.client.WireMock.put;
import static com.github.tomakehurst.wiremock.client.WireMock.putRequestedFor;
import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;

import com.github.tomakehurst.wiremock.WireMockServer;
import com.github.tomakehurst.wiremock.matching.UrlPattern;
import java.net.URI;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.S3Configuration;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;

public class S3ChunkedEncodingTest {

  private static WireMockServer server;

  @BeforeAll
  static void beforeAll() {
    server = new WireMockServer(wireMockConfig().dynamicPort());
    server.stubFor(put(UrlPattern.ANY).willReturn(ok()));
    server.start();
  }

  @AfterAll
  static void afterAll() {
    if (server != null) {
      server.stop();
    }
  }

  @BeforeEach
  void setUp() {
    server.resetRequests();
  }

  @Test
  void syncClientChunkedEncodingEnabled() {
    try (S3Client client = buildS3Client(buildS3Configuration(true))) {
      client.putObject(PutObjectRequest.builder().bucket("bucket").key("foobar").build(), RequestBody.empty());
    }
    server.verify(putRequestedFor(UrlPattern.ANY)
        .withHeader("Content-Encoding", matching("aws-chunked")));
  }

  @Test
  void syncClientChunkedEncodingDisabled() {
    try (S3Client client = buildS3Client(buildS3Configuration(false))) {
      client.putObject(PutObjectRequest.builder().bucket("bucket").key("foobar").build(), RequestBody.empty());
    }
    server.verify(putRequestedFor(UrlPattern.ANY)
        .withoutHeader("Content-Encoding"));
  }

  @Test
  void asyncClientChunkedEncodingEnabled() {
    try (S3AsyncClient client = buildS3AsyncClient(buildS3Configuration(true))) {
      client.putObject(PutObjectRequest.builder().bucket("bucket").key("foobar").build(), AsyncRequestBody.empty()).join();
    }
    server.verify(putRequestedFor(UrlPattern.ANY)
        .withHeader("Content-Encoding", matching("aws-chunked")));
  }

  @Test
  void asyncClientChunkedEncodingDisabled() {
    // Turns out S3AsyncClient doesn't respect the property disabling chunked encoding. This test will fail.
    try (S3AsyncClient client = buildS3AsyncClient(buildS3Configuration(false))) {
      client.putObject(PutObjectRequest.builder().bucket("bucket").key("foobar").build(), AsyncRequestBody.empty()).join();
    }
    server.verify(putRequestedFor(UrlPattern.ANY)
        .withoutHeader("Content-Encoding"));
  }

  @Test
  void asyncCrtClientChunkedEncodingEnabled() {
    // CRT always uses chunked encoding, there's no property to disable it. See https://github.com/aws/aws-sdk-java-v2/issues/4806
    try (S3AsyncClient client = S3AsyncClient.crtBuilder()
        .credentialsProvider(dummyCredentials())
        .endpointOverride(URI.create(server.baseUrl()))
        .build()) {
      client.putObject(PutObjectRequest.builder().bucket("bucket").key("foobar").build(), AsyncRequestBody.empty()).join();
    }
    server.verify(putRequestedFor(UrlPattern.ANY)
        .withHeader("Content-Encoding", matching("aws-chunked")));
  }


  private static S3Configuration buildS3Configuration(boolean chunkedEncoding) {
    return S3Configuration.builder()
        .chunkedEncodingEnabled(chunkedEncoding)
        .build();
  }

  private static S3Client buildS3Client(S3Configuration s3config) {
    return S3Client.builder()
        .serviceConfiguration(s3config)
        .credentialsProvider(dummyCredentials())
        .endpointOverride(URI.create(server.baseUrl()))
        .build();
  }

  private static S3AsyncClient buildS3AsyncClient(S3Configuration s3Config) {
    return S3AsyncClient.builder()
        .serviceConfiguration(s3Config)
        .credentialsProvider(dummyCredentials())
        .endpointOverride(URI.create(server.baseUrl()))
        .build();
  }

  private static StaticCredentialsProvider dummyCredentials() {
    return StaticCredentialsProvider.create(AwsBasicCredentials.create("dummy", "dummy"));
  }
}

Possible Solution

No response

Additional Information/Context

No response

AWS Java SDK version used

2.30.36

JDK version used

openjdk version "17.0.16" 2025-07-15 LTS

Operating System and version

Linux, kernel 6.12.31

[bhoradc]

Hello @vladykin,

Thank you for reporting the issue. I see similar behavior connecting to AWS S3 as well. It is obserrved post S3 default integrity protection changes that were released in SDK version 2.30.0. I believe the SDK has to send the Content-Encoding: aws-chunked header when it does the default CRC checksum, therefore overlooking the chunkedEncodingEnabled(false) setting for Async operation. But I will dig deeper to determine if this is an intended behavior change or something that needs to be fixed.

As a temporary workaround, you could disable the default integrity protection as explained in this announcement.

System.setProperty(SdkSystemSetting.AWS_REQUEST_CHECKSUM_CALCULATION.property(),
"WHEN_REQUIRED");

Regards,
Chaitanya

[vladykin]

@bhoradc, thanks, I confirm that

System.setProperty(SdkSystemSetting.AWS_REQUEST_CHECKSUM_CALCULATION.property(),
"WHEN_REQUIRED");

as well as

clientBuilder.requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)

disable sending Content-Encoding: aws-chunked header for S3AsyncClient (both default and CRT one) in my test case.
But surprisingly not for the S3Client. For S3Client, apparently, .chunkedEncodingEnabled(true) takes precedence.

I also tried the deprecated S3Configuration.Builder.checksumValidationEnabled(false). It also disables sending Content-Encoding: aws-chunked for S3AsyncClient. But again, not for S3Client. So, another inconsistency between sync and async clients.

[bhoradc]

Hi @vladykin,

Thanks for providing additonal details on this.

For S3Client, apparently, .chunkedEncodingEnabled(true) takes precedence.

I do not see this happening with AWS S3 connection. With .chunkedEncodingEnabled(true), it does not take precedence over the request_checksum_calculation set to WHEN_REQUIRED.

I also tried the deprecated S3Configuration.Builder.checksumValidationEnabled(false). It also disables sending Content-Encoding: aws-chunked for S3AsyncClient. But again, not for S3Client.

checksumValidationEnabled(false) disables sending Content-Encoding: aws-chunked for both S3AsyncClient and S3Client.

Starting v2.30.0, the checksumValidationEnabled() has been replaced by S3ClientBuilder#requestChecksumCalculation(RequestChecksumCalculation), which does work in both the sync and async clients.

Here's the code sample I have used to test these scenarios.

ChunkedEncodingTest.java

import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.S3Configuration;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import java.nio.charset.StandardCharsets;

public class ChunkedEncodingTest {
    
    public static void main(String[] args) {
//        System.setProperty(SdkSystemSetting.AWS_REQUEST_CHECKSUM_CALCULATION.property(),
//                "WHEN_REQUIRED");
       //testSyncClient();
       testAsyncClient();
    }
    
    private static void testSyncClient() {
        S3Configuration s3Config = S3Configuration.builder()
                .chunkedEncodingEnabled(false)
                //.checksumValidationEnabled(false)
                .build();
        
        System.out.println("S3Client chunkedEncodingEnabled value: " + s3Config.chunkedEncodingEnabled());
        
        S3Client syncClient = S3Client.builder()
                .region(Region.US_EAST_1)
                .serviceConfiguration(s3Config)
                //.requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                .build();

        PutObjectRequest putRequest = PutObjectRequest.builder()
                .bucket("i***6273")
                .key("test-***")
                .build();

        try {
            syncClient.putObject(putRequest, RequestBody.fromString("Test content for chunked encoding"));
            System.out.println("S3Client: PUT operation completed with small payload");
        } catch (Exception e) {
            System.out.println("S3Client small payload error: " + e.getMessage());
        }

        String largeContent = "x".repeat(10000);
        try {
            syncClient.putObject(putRequest.toBuilder().key("test-object-large").build(), 
                    RequestBody.fromString(largeContent));
            System.out.println("S3Client: PUT operation completed with large payload");
        } catch (Exception e) {
            System.out.println("S3Client error: " + e.getMessage());
        } finally {
            syncClient.close();
        }
    }
    
    private static void testAsyncClient() {
        S3Configuration s3Config = S3Configuration.builder()
                //.chunkedEncodingEnabled(false)
                .build();
        
        System.out.println("Default chunkedEncodingEnabled value: " + s3Config.chunkedEncodingEnabled());
        
        S3AsyncClient asyncClient = S3AsyncClient.builder()
                .region(Region.US_EAST_1)
                .serviceConfiguration(s3Config)
                //.requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                .build();

        PutObjectRequest putRequest = PutObjectRequest.builder()
                .bucket("i***6273")
                .key("test-***")
                .build();

        try {
            asyncClient.putObject(putRequest, AsyncRequestBody.fromString("Test content for chunked encoding"))
                    .whenComplete((response, throwable) -> {
                        if (throwable != null) {
                            System.out.println("S3AsyncClient fromString error: " + throwable.getMessage());
                        } else {
                            System.out.println("S3AsyncClient fromString: PUT operation completed");
                        }
                    }).join();
        } catch (Exception e) {
            System.out.println("S3AsyncClient fromString error: " + e.getMessage());
        }
    }
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>V2_chunkedEncodingEnabled_6387</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>22</maven.compiler.source>
        <maven.compiler.target>22</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-bom</artifactId>
            <version>2.19.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
            <version>2.33.1</version>
<!--            <version>2.29.52</version>-->
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j2-impl</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-1.2-api</artifactId>
        </dependency>
    </dependencies>
</project>

Regards,
Chaitanya

[alextwoods]

This should be fixed in: #6314

The Content-Encoding: aws-chunked is being added in the HttpChecksumStage when adding the checksum in trailer.

That change is not specific to this issue, but it does remove the specific check in the HttpChecksumStage - and the signers already correctly respect the settings.

[bhoradc]

Hi @vladykin

This issue has been fixed in Java SDK v2.37.0. I have validated that the following configuration now works correctly:

S3AsyncClient asyncClient = S3AsyncClient.builder()
    .region(Region.US_EAST_1)
    .serviceConfiguration(S3Configuration.builder()
        .chunkedEncodingEnabled(false)
        .build())
    .build();

When chunkedEncodingEnabled(false) is set, S3AsyncClient no longer sends Content-Encoding: aws-chunked header. Please let us know if you encounter any issues after upgrading.

Regards,
Chaitanya

[vladykin]

Thanks!