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 o cliente HTTP baseado em Netty
<a name="http-configuration-netty"></a>

O cliente HTTP padrão para operações assíncronas no AWS SDK for Java 2.x é o baseado em Netty. [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) O cliente baseado em Netty é baseado na estrutura de rede assíncrona orientada por eventos do [projeto Netty](https://netty.io/).

Como cliente HTTP alternativo, é possível usar o novo [cliente HTTP baseado em AWS CRT](http-configuration-crt.md). Este tópico mostra como configurar o `NettyNioAsyncHttpClient`.

## Acesse o `NettyNioAsyncHttpClient`
<a name="http-config-netty-access"></a>

Na maioria das situações, você usa o `NettyNioAsyncHttpClient` sem nenhuma configuração explícita em programas assíncronos. Você declara seus clientes de serviço assíncronos e o SDK configurará o `NettyNioAsyncHttpClient` com valores padrão para você.

Se você quiser configurar o `NettyNioAsyncHttpClient` explicitamente ou usá-lo com vários clientes de serviço, precisará disponibilizá-lo para configuração.

### Nenhuma configuração necessária
<a name="http-config-netty-no-config"></a>

Quando você declara uma dependência de um cliente de serviço no Maven, o SDK adiciona uma dependência de *tempo de execução* ao artefato `netty-nio-client`. Isso torna a classe `NettyNioAsyncHttpClient` disponível para o código em runtime, mas não no momento da compilação. Se você não estiver configurando o cliente HTTP baseado em Netty, não precisará especificar uma dependência para ele.

No seguinte trecho XML de um arquivo `pom.xml` do Maven, a dependência declarada com `<artifactId>dynamodb-enhanced</artifactId>` traz transitivamente o cliente HTTP baseado em Netty. Você não precisa declarar uma dependência especificamente para isso.

```
<dependencyManagement>
   <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.27.21</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>dynamodb-enhanced</artifactId>
    </dependency>
</dependencies>
```

Com essas dependências, você não pode fazer nenhuma alteração na configuração HTTP, pois a biblioteca `NettyNioAsyncHttpClient` está apenas no caminho de classe em runtime. 

### Configuração necessária
<a name="http-config-netty-yes-config"></a>

Para configurar o `NettyNioAsyncHttpClient`, você precisa adicionar uma dependência no artefato `netty-nio-client` em tempo de *compilação*. 

Consulte o exemplo a seguir de um arquivo `pom.xml` do Maven para configurar o `NettyNioAsyncHttpClient`.

```
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>2.27.21</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>dynamodb-enhanced</artifactId>
        </dependency>
        <!-- By adding the netty-nio-client dependency, NettyNioAsyncHttpClient will be 
             added to the compile classpath so you can configure it. -->
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>netty-nio-client</artifactId>
        </dependency>
    </dependencies>
```

## Usar e configurar o `NettyNioAsyncHttpClient`
<a name="http-netty-config"></a>

Você pode configurar uma instância do `NettyNioAsyncHttpClient` 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 o [NettyNioAsyncHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html) para configurar as propriedades da instância do cliente HTTP baseada em Netty.

### Prática recomendada: dedicar uma instância `NettyNioAsyncHttpClient` a um cliente de serviço
<a name="http-config-netty-one-client"></a>

Se você precisar configurar uma instância do `NettyNioAsyncHttpClient`, recomendamos criar uma instância `NettyNioAsyncHttpClient` dedicada. Faça isso usando o método `httpClientBuilder` do builder do cliente do serviço. Dessa forma, o ciclo de vida do cliente HTTP é gerenciado pelo SDK, o que ajuda a evitar possíveis vazamentos de memória se a instância do `NettyNioAsyncHttpClient` não for fechada quando não for mais necessária.

O exemplo a seguir cria uma instância `DynamoDbAsyncClient`, que também é usada por uma instância `DynamoDbEnhancedAsyncClient`. A instância `DynamoDbAsyncClient` contém a instância `NettyNioAsyncHttpClient` com valores `connectionTimeout` e `maxConcurrency`. A instância HTTP é criada usando o método `httpClientBuilder` do `DynamoDbAsyncClient.Builder`.

 **Importações** 

```
import software.amazon.awssdk.auth.credentials.EnvironmentVariableCredentialsProvider;
import software.amazon.awssdk.awscore.defaultsmode.DefaultsMode;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient;
import software.amazon.awssdk.enhanced.dynamodb.extensions.AutoGeneratedTimestampRecordExtension;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import java.time.Duration;
```

 **Código** 

```
// DynamoDbAsyncClient is the lower-level client used by the enhanced client.
DynamoDbAsyncClient dynamoDbAsyncClient = 
    DynamoDbAsyncClient
        .builder()
            .httpClientBuilder(NettyNioAsyncHttpClient.builder()
            .connectionTimeout(Duration.ofMillis(5_000))
            .maxConcurrency(100)
            .tlsNegotiationTimeout(Duration.ofMillis(3_500)))
        .defaultsMode(DefaultsMode.IN_REGION)
        .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
        .build();

// Singleton: Use dynamoDbAsyncClient and enhancedClient for all requests.
DynamoDbEnhancedAsyncClient enhancedClient = 
    DynamoDbEnhancedAsyncClient
        .builder()
        .dynamoDbClient(dynamoDbAsyncClient)
        .extensions(AutoGeneratedTimestampRecordExtension.create())
        .build();

// Perform work with the dynamoDbAsyncClient and enhancedClient.

// Requests completed: Close dynamoDbAsyncClient.
dynamoDbAsyncClient.close();
```

### Abordagem alternativa: compartilhar uma instância `NettyNioAsyncHttpClient`
<a name="http-config-netty-multi-clients"></a>

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

**nota**  
Quando uma instância `NettyNioAsyncHttpClient` é compartilhada, você deve fechá-la quando ela estiver pronta para ser descartada. O SDK não fechará a instância quando o cliente de serviço for fechado.

O exemplo a seguir configura um cliente HTTP baseado em Netty, que é usado por dois clientes de serviço. A instância `NettyNioAsyncHttpClient` configurada é transmitida ao método `httpClient` de cada criador. Quando os clientes do serviço e o cliente HTTP não são mais necessários, o código os fecha explicitamente. O código fecha o cliente HTTP por último.

**Importações**

```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```

 **Código** 

```
// Create a NettyNioAsyncHttpClient shared instance.
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.builder().maxConcurrency(100).build();

// Singletons: Use the s3AsyncClient, dbAsyncClient, and enhancedAsyncClient for all requests.
S3AsyncClient s3AsyncClient = 
    S3AsyncClient.builder()
                 .httpClient(nettyHttpClient)
                 .build();

DynamoDbAsyncClient dbAsyncClient = 
    DynamoDbAsyncClient.builder()
                       .httpClient(nettyHttpClient)
                       .defaultsMode(DefaultsMode.IN_REGION)
                       .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
                       .build();

DynamoDbEnhancedAsyncClient enhancedAsyncClient = 
    DynamoDbEnhancedAsyncClient.builder()
                               .dynamoDbClient(dbAsyncClient)
                               .extensions(AutoGeneratedTimestampRecordExtension.create())
                               .build();

// Perform work with s3AsyncClient, dbAsyncClient, and enhancedAsyncClient.

// Requests completed: Close all service clients.
s3AsyncClient.close();
dbAsyncClient.close()
nettyHttpClient.close();  // Explicitly close nettyHttpClient.
```

## Configurar a negociação do protocolo ALPN
<a name="http-netty-config-alpn"></a>

O ALPN (negociação do protocolo da camada da aplicação) é uma extensão TLS que permite que a camada da aplicação negocie qual protocolo deve ser executado em uma conexão segura de uma maneira que evite viagens de ida e volta adicionais e ofereça melhor desempenho.

Para permitir que o cliente HTTP baseado em Netty use o ALPN, chame os métodos do compilador conforme mostrado no seguinte trecho:

```
import software.amazon.awssdk.http.Protocol;
import software.amazon.awssdk.http.ProtocolNegotiation;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.services.transcribestreaming.TranscribeStreamingAsyncClient;


// Configure the Netty-based HTTP client to use the ALPN protocol.
SdkAsyncHttpClient nettyClient = NettyNioAsyncHttpClient.builder()
                                                        .protocol(Protocol.HTTP2)
                                                        .protocolNegotiation(ProtocolNegotiation.ALPN)
                                                        .build();
// Use the Netty-based HTTP client with a service client.
TranscribeStreamingAsyncClient transcribeClient = TranscribeStreamingAsyncClient.builder()
                                                                                .httpClient(nettyClient)
                                                                                .build();
```

Atualmente, a negociação do protocolo ALPN funciona somente com o protocolo HTTP/2, conforme mostrado no trecho anterior.

## Exemplo de configuração do proxy
<a name="http-config-netty-proxy-ex"></a>

O trecho de código a seguir usa o [builder de configuração de proxy para o cliente HTTP Netty](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/ProxyConfiguration.Builder.html).

```
SdkAsyncHttpClient nettyHttpClient = NettyNioAsyncHttpClient.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 proxy HTTPS, a propriedade `scheme` deve ser definida no código como `https`. Se a propriedade scheme não estiver definida no código, o esquema usará HTTP como padrão, e o SDK procurará somente as propriedades do sistema `http.*`.

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 nettyHttpClient = NettyNioAsyncHttpClient.builder()
    .proxyConfiguration(ProxyConfiguration.builder()
        .useSystemPropertyValues(Boolean.FALSE)
        .build())
    .build();

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