Configurar HTTP clientes AWS CRT baseados em - AWS SDK for Java 2.x
Acesse os HTTP clientes AWS CRT baseadosUse e configure um HTTP cliente AWS CRT baseadoDefinir um HTTP cliente AWS CRT baseado como padrãoConfiguração avançadaHTTP/2 suporteExemplo de configuração do proxy

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

Configurar HTTP clientes AWS CRT baseados em

Os HTTP clientes AWS CRT baseados incluem o síncrono AwsCrtHttpCliente o AwsCrtAsyncHttpClientassíncrono. Os HTTP clientes AWS CRT baseados oferecem os seguintes benefícios HTTP ao cliente:

  • Tempo de SDK inicialização mais rápido

  • Menor espaço ocupado na memória

  • Tempo de latência reduzido

  • Gerenciamento de integridade da conexão

  • DNSbalanceamento de carga

AWS CRTcomponentes baseados no SDK

Os HTTPclientes AWS CRT baseados, descritos neste tópico, e o cliente S3 AWS CRT baseado são componentes diferentes noSDK.

Os HTTPclientes síncronos e assíncronos são interfaces AWS CRT de SDK HTTP cliente de implementações e são usados para comunicação geral. HTTP Eles são alternativas aos outros HTTP clientes síncronos ou assíncronos do SDK com benefícios adicionais.

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

Embora ambos os componentes usem bibliotecas do AWS Common Runtime, os HTTP clientes AWS CRT baseados não usam a biblioteca aws-c-s 3 e não oferecem suporte aos recursos de upload API de várias partes do S3. O cliente S3 AWS CRT baseado, por outro lado, foi desenvolvido especificamente para oferecer suporte aos recursos de upload de várias partes do S3. API

Acesse os HTTP clientes AWS CRT baseados

Antes de usar os HTTP clientes AWS CRT baseados, adicione o aws-crt-client artefato com uma versão mínima de 2.22.0 às dependências do seu projeto.

Use uma das opções a seguir para configurar seu pom.xml arquivo Maven.

nota

Você pode optar por usar a opção jar específica da plataforma se precisar manter o tamanho das dependências de tempo de execução menor, por exemplo, se seu aplicativo for executado em uma função. AWS Lambda

Uber-jar option

Por padrão, o aws-crt-client usa um uber-jar de AWS CRT artefatos que contém binários para várias plataformas, incluindo Linux, Windows e macOS.

<project>
   <properties>
     <aws.sdk.java.version>2.29.10*</aws.sdk.java.version>
  </properties>
  <dependencyManagement>
   <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>${aws.sdk.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
   </dependencies>
  </dependencyManagement>
  <dependencies>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>aws-crt-client</artifactId>
   </dependency>
  </dependencies>
</project>

*Substitua a versão mostrada em vermelho pela versão do Java SDK que você deseja usar. Encontre as últimas novidades sobre o Maven Central.

Platform-specific jar option

Para restringir o tempo de execução do Java à versão específica da plataforma da AWS CRT biblioteca, faça as seguintes alterações na opção Uber-JAR.

  • Adicione um exclusions elemento ao SDK aws-crt-client artefato. Essa exclusão impede o uso transitivo SDK do uber-jar. AWS CRT

  • Adicione um elemento de dependência para a versão específica da AWS CRT plataforma que você precisa. Consulte as etapas para determinar a versão do AWS CRT artefato abaixo para saber como determinar a versão correta.

<project>
   <properties>
     <aws.sdk.java.version>2.29.101</aws.sdk.java.version>
  </properties>
   <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.sdk.java.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>aws-crt-client</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk.crt</groupId>
                    <artifactId>aws-crt</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk.crt</groupId>
            <artifactId>aws-crt</artifactId>
            <version>0.31.32</version>
            <classifier>linux-x86_643</classifier>
        </dependency>
    </dependencies>

1 Substitua a versão mostrada em vermelho pela versão do Java SDK que você deseja usar. Encontre as últimas novidades sobre o Maven Central.

2 Substitua a versão software.amazon.awssdk.crt:aws-crt que seria fornecida pela opção Uber-JAR. Consulte as etapas a seguir para determinar a versão do AWS CRT artefato.

3 Substitua o classifier valor por um para sua plataforma. Consulte a GitHub página AWS CRT para Java para obter uma lista dos valores disponíveis.

Etapas para determinar a versão do AWS CRT artefato

Use as etapas a seguir para determinar a versão do AWS CRT artefato compatível com a versão do SDK para Java que você está usando.

  1. Configure seu pom.xml arquivo conforme mostrado na opção Uber-JAR. Essa configuração permite que você veja qual versão software.amazon.awssdk.crt:aws-crt do SDK traz por padrão.

  2. Na raiz do projeto (no mesmo diretório do pom.xml arquivo), execute o seguinte comando do Maven:

    mvn dependency:tree -Dincludes=software.amazon.awssdk.crt:aws-crt

    O Maven pode realizar outras ações, mas no final você deve ver a saída do console da software.amazon.awssdk.crt:aws-crt dependência que o SDK transitivamente usa. O trecho a seguir mostra um exemplo de saída com base em uma SDK versão do: 2.29.10

    [INFO] org.example:yourProject:jar:1.0-SNAPSHOT
[INFO] \- software.amazon.awssdk:aws-crt-client:jar:2.29.10:compile
[INFO]    \- software.amazon.awssdk.crt:aws-crt:jar:0.31.3:compile

  3. Use a versão que o console mostra para o software.amazon.awssdk.crt:aws-crt artefato. Nesse caso, adicione 0.31.3 ao seu pom.xml arquivo.

Use e configure um HTTP cliente AWS CRT baseado

Você pode configurar um HTTP cliente AWS CRT baseado junto com a criação de um cliente de serviço ou pode configurar uma única instância para compartilhar entre vários clientes de serviço.

Com qualquer abordagem, você usa um construtor para configurar as propriedades da instância HTTP cliente AWS CRT baseada.

Prática recomendada: dedicar uma instância do a um cliente de serviço

Se você precisar configurar uma instância de um HTTP cliente AWS CRT baseado, recomendamos que você dedique a instância construindo-a junto com o cliente de serviço. Faça isso usando o método httpClientBuilder do builder do cliente do serviço. Dessa forma, o ciclo de vida do HTTP cliente é gerenciado peloSDK, o que ajuda a evitar possíveis vazamentos de memória se a instância do HTTP cliente AWS CRT baseada não for fechada quando não for mais necessária.

O exemplo a seguir cria um cliente de serviço S3 e configura um HTTP cliente AWS CRT baseado com valores connectionTimeout e. maxConcurrency

Synchronous client

Importações

import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;

Código 

// Singleton: Use s3Client for all requests.
S3Client s3Client = S3Client.builder()
    .httpClientBuilder(AwsCrtHttpClient
        .builder()
        .connectionTimeout(Duration.ofSeconds(3))
        .maxConcurrency(100))
    .build();

// Perform work with the s3Client.

// Requests completed: Close the s3Client.
s3Client.close();
Asynchronous client

Importações

import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;

Código 

// Singleton: Use s3AsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
    .httpClientBuilder(AwsCrtAsyncHttpClient
        .builder()
        .connectionTimeout(Duration.ofSeconds(3))
        .maxConcurrency(100))
    .build();

// Perform work with the s3AsyncClient.

// Requests completed: Close the s3AsyncClient.
s3AsyncClient.close();

Abordagem alternativa: compartilhar uma instância do

Para ajudar a reduzir o uso de recursos e memória do seu aplicativo, você pode configurar um HTTP cliente AWS CRT baseado e compartilhá-lo entre vários clientes de serviço. O pool de HTTP conexões será compartilhado, o que reduz o uso de recursos.

nota

Quando uma instância HTTP cliente AWS CRT baseada é compartilhada, você deve fechá-la quando ela estiver pronta para ser descartada. Não SDK fechará a instância quando o cliente do serviço for fechado.

O exemplo a seguir configura uma instância de HTTP cliente AWS CRT baseada com maxConcurrency valores connectionTimeout e. A instância configurada é transmitida ao método httpClient do criador de cada cliente de serviço. Quando os clientes do serviço e o HTTP cliente não são mais necessários, eles são explicitamente fechados. O HTTP cliente é fechado por último.

Synchronous client

Importações

import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;

Código 

// Create an AwsCrtHttpClient shared instance.
SdkHttpClient crtHttpClient = AwsCrtHttpClient.builder()
    .connectionTimeout(Duration.ofSeconds(3))
    .maxConcurrency(100)
    .build();

// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client = S3Client.builder()
    .httpClient(crtHttpClient)
    .credentialsProvider(EnvironmentVariableCredentialsProvider.crea
    .defaultsMode(DefaultsMode.IN_REGION)
    .region(Region.US_EAST_1)
    .build();

DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
    .httpClient(crtHttpClient)
    .credentialsProvider(EnvironmentVariableCredentialsProvider.crea
    .defaultsMode(DefaultsMode.IN_REGION)
    .region(Region.US_EAST_1)
    .build();

// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
crtHttpClient.close();  // Explicitly close crtHttpClient.
Asynchronous client

Importações

import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;

Código 

// Create an AwsCrtAsyncHttpClient shared instance.
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
    .connectionTimeout(Duration.ofSeconds(3))
    .maxConcurrency(100)
    .build();

// Singletons: Use the s3AsyncClient and dynamoDbAsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
    .httpClient(crtAsyncHttpClient)
    .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
    .defaultsMode(DefaultsMode.IN_REGION)
    .region(Region.US_EAST_1)
    .build();

DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbAsyncClient.builder()
    .httpClient(crtAsyncHttpClient)
    .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
    .defaultsMode(DefaultsMode.IN_REGION)
    .region(Region.US_EAST_1)
    .build();

// Requests completed: Close all service clients.
s3AsyncClient.close();
dynamoDbAsyncClient.close();
crtAsyncHttpClient.close();  // Explicitly close crtAsyncHttpClient.

Definir um HTTP cliente AWS CRT baseado como padrão

Você pode configurar seu arquivo de compilação do Maven para SDK usar um HTTP cliente AWS CRT baseado como HTTP cliente padrão para clientes de serviço.

Você faz isso adicionando um exclusions elemento com as dependências padrão do HTTP cliente a cada artefato do cliente de serviço.

No pom.xml exemplo a seguir, ele SDK usa um HTTP cliente AWS CRT baseado para serviços do S3. Se o cliente de serviço em seu código for umS3AsyncClient, os SDK usosAwsCrtAsyncHttpClient. Se o cliente de serviço for um S3Client, os SDK usos. AwsCrtHttpClient Com essa configuração, o HTTP cliente assíncrono padrão baseado em Netty e o síncrono padrão baseado em Apache não estão disponíveis. HTTP

<project>
   <properties>
     <aws.sdk.version>VERSION</aws.sdk.version>
  </properties>
  <dependencies>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>s3</artifactId>
      <version>${aws.sdk.version}</version>
      <exclusions>
         <exclusion>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>netty-nio-client</artifactId>
         </exclusion>
         <exclusion>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId>
         </exclusion>
      </exclusions>
   </dependency>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>aws-crt-client</artifactId>
   </dependency>
  </dependencies>
</project>

Visite o repositório central do Maven para obter as últimas novidades VERSION value.

nota

Se vários clientes de serviço forem declarados em um pom.xml arquivo, todos precisarão do exclusions XML elemento.

Usar uma propriedade do sistema Java

Para usar os HTTP clientes AWS CRT baseados como padrão HTTP para seu aplicativo, você pode definir a propriedade do sistema Java software.amazon.awssdk.http.async.service.impl com um valor desoftware.amazon.awssdk.http.crt.AwsCrtSdkHttpService.

Para definir durante a inicialização do aplicativo, execute um comando semelhante ao seguinte.

java app.jar -Dsoftware.amazon.awssdk.http.async.service.impl=\
software.amazon.awssdk.http.crt.AwsCrtSdkHttpService

Use o trecho de código a seguir para definir a propriedade do sistema no código do seu aplicativo.

System.setProperty("software.amazon.awssdk.http.async.service.impl",
"software.amazon.awssdk.http.crt.AwsCrtSdkHttpService");
nota

Você precisa adicionar uma dependência do aws-crt-client artefato em seu poml.xml arquivo ao usar uma propriedade do sistema para configurar o uso dos clientes AWS CRT baseadosHTTP.

Configuração avançada de HTTP clientes AWS CRT baseados

Você pode usar várias configurações dos HTTP clientes AWS CRT baseados, incluindo configuração de integridade da conexão e tempo máximo de inatividade. Você pode revisar as opções de configuração disponíveis para o AwsCrtAsyncHttpClient. É possível configurar as mesmas opções para o AwsCrtHttpClient.

Configuração de integridade da conexão

Você pode configurar a integridade da conexão para os HTTP clientes AWS CRT baseados usando o connectionHealthConfiguration método no construtor de HTTP clientes.

O exemplo a seguir cria um cliente de serviço S3 que usa uma instância de HTTP cliente AWS CRT baseada configurada com configuração de integridade da conexão e um tempo máximo de inatividade para conexões.

Synchronous client

Importações

import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;

Código 

// Singleton: Use the s3Client for all requests.
S3Client s3Client = S3Client.builder()
    .httpClientBuilder(AwsCrtHttpClient
        .builder()
        .connectionHealthConfiguration(builder -> builder
            .minimumThroughputInBps(32000L)
            .minimumThroughputTimeout(Duration.ofSeconds(3)))
        .connectionMaxIdleTime(Duration.ofSeconds(5)))
    .build();

// Perform work with s3Client.

// Requests complete: Close the service client.
s3Client.close();
Asynchronous client

Importações

import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;

Código 

// Singleton: Use the s3AsyncClient for all requests.
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
    .httpClientBuilder(AwsCrtAsyncHttpClient
        .builder()
        .connectionHealthConfiguration(builder -> builder
            .minimumThroughputInBps(32000L)
            .minimumThroughputTimeout(Duration.ofSeconds(3)))
        .connectionMaxIdleTime(Duration.ofSeconds(5)))
    .build();

// Perform work with s3AsyncClient.

// Requests complete: Close the service client.
s3AsyncClient.close();

HTTP/2 suporte

O protocolo HTTP /2 ainda não é suportado nos HTTP clientes AWS CRT baseados, mas está planejado para uma versão futura.

Enquanto isso, se você estiver usando clientes de serviço que precisam de suporte HTTP /2, como o KinesisAsyncClientou o TranscribeStreamingAsyncClient, considere usar o. NettyNioAsyncHttpClient

Exemplo de configuração do proxy

O trecho de código a seguir mostra o uso do ProxyConfiguration.Builder que você usa para definir a configuração de proxy no código.

Synchronous client

Importações

import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;

Código 

SdkHttpClient crtHttpClient = AwsCrtHttpClient.builder()
    .proxyConfiguration(ProxyConfiguration.builder()
        .scheme("https")
        .host("myproxy")
        .port(1234)
        .username("username")
        .password("password")
        .nonProxyHosts(Set.of("localhost", "host.example.com"))
        .build())
    .build();
Asynchronous client

Importações

import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;

Código 

SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
    .proxyConfiguration(ProxyConfiguration.builder()
        .scheme("https")
        .host("myproxy")
        .port(1234)
        .username("username")
        .password("password")
        .nonProxyHosts(Set.of("localhost", "host.example.com"))
        .build())
    .build();

As propriedades equivalentes do sistema Java para a configuração do proxy são mostradas no trecho da linha de comando a seguir.

$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
Importante

Para usar qualquer uma das propriedades do sistema HTTPS proxy, a scheme propriedade deve ser definida no código comohttps. Se a propriedade do esquema não estiver definida no código, o esquema assumirá como padrão HTTP e procurará somente as SDK propriedades http.* do sistema.

A configuração equivalente que usa variáveis de ambiente é:

// Set the following environment variables.
// $ export HTTPS_PROXY="https://username:password@myproxy:1234"
// $ export NO_PROXY="localhost|host.example.com"

// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkAsyncHttpClient crtAsyncHttpClient = AwsCrtAsyncHttpClient.builder()
    .proxyConfiguration(ProxyConfiguration.builder()
        .scheme("https")
        .useSystemPropertyValues(Boolean.FALSE)
        .build())
    .build();

// Run the application.
// $ java -cp ... App