As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Usar um cliente do S3 de alta performance: cliente do S3 baseado no AWS CRT

O cliente do S3 da AWS baseado em CRT, construído com base no Common Runtime (CRT) da AWS, é um cliente assíncrono alternativo do S3. Ele transfere objetos de e para o Amazon Simple Storage Service (Amazon S3) com desempenho e confiabilidade aprimorados usando automaticamente a API de upload de várias partes e as buscas de intervalo de bytes do Amazon S3.

O cliente do S3 da AWS baseado em CRT melhora a confiabilidade da transferência caso haja uma falha na rede. A confiabilidade é aprimorada ao realizar novas tentativas de partes individuais com falha em uma transferência de arquivos sem reiniciar a transferência desde o início.

Além disso, o cliente do S3 da AWS baseado em CRT oferece um pool de conexões aprimorado e balanceamento de carga do Sistema de Nomes de Domínio (DNS), o que também melhora o throughput.

Você pode usar o cliente do S3 da AWS baseado em CRT no lugar do cliente assíncrono do S3 padrão do SDK e aproveitar imediatamente seu throughput aprimorado.

AWS Componentes da baseados em CRT no SDK

O cliente do S3 da AWS baseado em CRT, descrito neste tópico, e o cliente de HTTP da AWS baseado em CRT são componentes diferentes no SDK.

O cliente do S3 baseado no AWS CRT é uma implementação da interface S3AsyncClient e é usado para trabalhar com o serviço Amazon S3. Ele é uma alternativa à implementação da interface S3AsyncClient baseada em Java e oferece vários benefícios.

O cliente HTTP da AWS baseado em CRT é uma implementação da interface SdkAsyncHttpClient e é usado para a comunicação HTTP em geral. Essa é uma alternativa à implementação da interface SdkAsyncHttpClient do Netty e oferece várias vantagens.

Embora ambos os componentes usem bibliotecas do Common Runtime da AWS, o cliente do S3 da baseado no AWS CRT usa a biblioteca aws-c-s3 e oferece suporte aos atributos da API de upload de várias partes do S3. Como o cliente HTTP da AWS baseado em CRT é destinado ao uso geral, ele não oferece suporte aos atributos da API de upload de várias partes do S3.

Adicionar dependências para usar o cliente do S3 da AWS baseado em CRT

Para usar o cliente do S3 da AWS baseado em CRT, adicione as duas dependências a seguir ao seu arquivo de projeto Maven. O exemplo mostra as versões mínimas a serem usadas. Pesquisar no repositório central do Maven as versões mais recentes dos artefatos s3 e aws-crt.

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3</artifactId>
  <version>2.27.21</version>
</dependency>
<dependency>
  <groupId>software.amazon.awssdk.crt</groupId>
  <artifactId>aws-crt</artifactId>
  <version>0.30.11</version>
</dependency>

Criar uma instância do cliente do S3 da AWS baseado em CRT

Crie uma instância do cliente do S3 da AWS baseado em CRT com as configurações padrão, conforme mostrado no trecho de código a seguir.

S3AsyncClient s3AsyncClient = S3AsyncClient.crtCreate();

Para configurar o cliente, use o criador de cliente CRT da AWS. Você pode alternar do cliente assíncrono do S3 padrão para o cliente da AWS baseado em CRT alterando o método de construtor.

import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;


S3AsyncClient s3AsyncClient = 
        S3AsyncClient.crtBuilder()
                     .credentialsProvider(DefaultCredentialsProvider.create())
                     .region(Region.US_WEST_2)
                     .targetThroughputInGbps(20.0)
                     .minimumPartSizeInBytes(8 * 1025 * 1024L)
                     .build();      

Usar o cliente do S3 baseado em CRT da AWS

Use o cliente do S3 da AWS baseado em CRT para chamar as operações de API do Amazon S3. O exemplo a seguir demonstra as operações PutObject e GetObject disponíveis por meio do AWS SDK para Java.

import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;


S3AsyncClient s3Client = S3AsyncClient.crtCreate();

// Upload a local file to Amazon S3.
PutObjectResponse putObjectResponse = 
      s3Client.putObject(req -> req.bucket(<BUCKET_NAME>)
                                   .key(<KEY_NAME>),
                        AsyncRequestBody.fromFile(Paths.get(<FILE_NAME>)))
              .join();

// Download an object from Amazon S3 to a local file.
GetObjectResponse getObjectResponse = 
      s3Client.getObject(req -> req.bucket(<BUCKET_NAME>)
                                   .key(<KEY_NAME>),
                        AsyncResponseTransformer.toFile(Paths.get(<FILE_NAME>)))
              .join();
     

Upload de fluxos de tamanho desconhecido

Uma vantagem significativa do cliente S3 baseado no AWS CRT é sua capacidade de lidar com fluxos de entrada de tamanho desconhecido com eficiência. Isso é útil principalmente quando você precisa carregar dados de uma origem em que o tamanho total não pode ser determinado com antecedência.

public PutObjectResponse crtClient_stream_unknown_size(String bucketName, String key, InputStream inputStream) {

    S3AsyncClient s3AsyncClient = S3AsyncClient.crtCreate();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    AsyncRequestBody body = AsyncRequestBody.fromInputStream(inputStream, null, executor);  // 'null' indicates that the
                                                                                            // content length is unknown.
    CompletableFuture<PutObjectResponse> responseFuture =
            s3AsyncClient.putObject(r -> r.bucket(bucketName).key(key), body)
                    .exceptionally(e -> {
                        if (e != null){
                            logger.error(e.getMessage(), e);
                        }
                        return null;
                    });

    PutObjectResponse response = responseFuture.join(); // Wait for the response.
    executor.shutdown();
    return response;
}

Esse recurso ajuda a evitar problemas comuns com os carregamentos tradicionais, nos quais uma especificação incorreta do tamanho do conteúdo pode resultar em objetos truncados ou em uploads malsucedidos.

Limitações de configuração

O cliente do S3 baseado no AWS CRT e o cliente assíncrono do S3 baseado em Java fornecem recursos comparáveis, com o cliente do S3 baseado no AWS CRT oferecendo uma vantagem de desempenho. No entanto, o cliente do S3 baseado no AWS CRT não tem as configurações que o cliente assíncrono do S3 baseado em Java tem. Essas configurações incluem:

Consulte uma lista completa das diferenças de configuração na referência da API.