Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurare i client HTTP in AWS SDK for Java 2.x
È possibile modificare il client HTTP da utilizzare per il client di servizio e modificare la configurazione predefinita per i client HTTP con AWS SDK for Java 2.x. Questa sezione illustra i client e le impostazioni HTTP per l'SDK.
## Client HTTP disponibili nell'SDK for Java
### Client sincroni
I client HTTP sincroni nell'SDK for Java implementano [SdkHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/SdkHttpClient.html)l'interfaccia. Un client di servizio sincrono, come il `S3Client` o il`DynamoDbClient`, richiede l'uso di un client HTTP sincrono. AWS SDK per Java Offre tre client HTTP sincroni.
**ApacheHttpClient (impostazione predefinita)**
[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)è il client HTTP predefinito per i client di servizi sincroni. Per informazioni sulla configurazione di`ApacheHttpClient`, vedere. [Configurare il client HTTP basato su Apache](http-configuration-apache.md)
**AwsCrtHttpClient**
[AwsCrtHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html)fornisce un throughput elevato e un IO non bloccante. È basato sul client Http AWS Common Runtime (CRT). Per informazioni sulla configurazione `AwsCrtHttpClient` e sul suo utilizzo con i client di servizio, vedere. [Configurazione AWS dei client HTTP basati su CRT](http-configuration-crt.md)
**UrlConnectionHttpClient**
Per ridurre al minimo il numero di jar e librerie di terze parti utilizzate dall'applicazione, è possibile utilizzare il. [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html) Per informazioni sulla configurazione di`UrlConnectionHttpClient`, vedere. [Configurare il client HTTP URLConnection basato](http-configuration-url.md)
**Apache 5 HttpClient**
[Apache5 HttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.html) *è una versione aggiornata basata su `ApacheHttpClient` Apache 5.x. HttpClient La versione 5.x* è la versione gestita attivamente da Apache e migliora la versione precedente utilizzata `ApacheHttpClient` offrendo la compatibilità con l'ecosistema Java moderno, incluso il supporto dei thread virtuali per Java 21 e una maggiore flessibilità di registrazione tramite SLF4 J. che `Apache5HttpClient` sostituirà `ApacheHttpClient` come client sincrono predefinito in una versione futura dell'SDK for AWS Java 2.x. Ha un'API e caratteristiche identiche, che la rendono ideale come sostituto immediato. Per informazioni sulla configurazione di, vedere. `Apache5HttpClient` [Configurazione del client HTTP basato su Apache 5.x](http-configuration-apache5.md)
### Client asincroni
I client HTTP asincroni nell'SDK for Java implementano l'interfaccia. [SdkAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/async/SdkAsyncHttpClient.html) Un client di servizio asincrono, come il `S3AsyncClient` o il, richiede l'uso di un client HTTP `DynamoDbAsyncClient` asincrono. Offre AWS SDK per Java due client HTTP asincroni.
**NettyNioAsyncHttpClient (impostazione predefinita)**
[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)è il client HTTP predefinito utilizzato dai client asincroni. Per informazioni sulla configurazione di, vedere. `NettyNioAsyncHttpClient` [Configurazione del client HTTP basato su Netty](http-configuration-netty.md)
**AwsCrtAsyncHttpClient**
[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)Si basa sul client HTTP AWS Common Runtime (CRT). Per informazioni sulla configurazione di`AwsCrtAsyncHttpClient`, vedere. [Configurazione AWS dei client HTTP basati su CRT](http-configuration-crt.md)
## Raccomandazioni sui client HTTP
Quando si sceglie un'implementazione del client HTTP entrano in gioco diversi fattori. Utilizza le seguenti informazioni per aiutarti a decidere.
### diagramma di flusso dei consigli
Il seguente diagramma di flusso fornisce indicazioni generali per aiutarti a determinare quale client HTTP utilizzare.
![\[Diagramma di flusso dei consigli sui client HTTP.\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/images/JavaDevGuide-HTTPflowchart-DI.png)
### Confronto tra client HTTP
La tabella seguente fornisce informazioni dettagliate per ogni client HTTP.
| Client HTTP | Sincronizzazione o asincrono | Quando utilizzare | Limitazione/inconveniente |
| --- | --- | --- | --- |
| Client HTTP basato su Apache *(client HTTP di sincronizzazione predefinito)* | Sync | Usalo se preferisci una bassa latenza rispetto a un throughput elevato | Tempo di avvio più lento rispetto ad altri client HTTP |
| Client HTTP basato su URLConnection | Sync | Usalo se hai una forte esigenza di limitare le dipendenze di terze parti | Non supporta il metodo HTTP PATCH, richiesto da alcune API come le operazioni di Amazon APIGateway Update |
| AWS Client HTTP di sincronizzazione basato su CRT 1 | Sync | • Usalo se l'applicazione è in esecuzione in AWS Lambda • Usalo se preferisci un throughput elevato rispetto a una bassa latenza • Usalo se preferisci sincronizzare i client SDK | Le seguenti proprietà del sistema Java non sono supportate: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/http-configuration.html) |
| Client HTTP basato su Netty *(client HTTP asincrono predefinito)* | Asincrono | • Usalo se l'applicazione richiama richiami APIs che richiedono il supporto HTTP/2 come l'API Kinesis [SubscribeToShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_SubscribeToShard.html) | Tempo di avvio più lento rispetto ad altri client HTTP |
| AWS Client HTTP asincrono basato su CRT 1 | Asincrono | • Usalo se l'applicazione è in esecuzione in AWS Lambda• Usalo se preferisci un throughput elevato rispetto a una bassa latenza• Usalo se preferisci i client SDK asincroni | • Non supporta client di servizio che richiedono il supporto HTTP/2 come e `KinesisAsynClient` `TranscribeStreamingAsyncClient` Le seguenti proprietà del sistema Java non sono supportate: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/http-configuration.html) |
1 A causa dei loro vantaggi aggiuntivi, si consiglia di utilizzare i client HTTP AWS basati su CRT, se possibile.
## Impostazioni predefinite di configurazione intelligente
La AWS SDK for Java 2.x (versione 2.17.102 o successiva) offre una funzionalità di configurazione predefinita intelligente. Questa funzionalità ottimizza due proprietà del client HTTP insieme ad altre proprietà che non influiscono sul client HTTP.
Le impostazioni predefinite di configurazione intelligente impostano valori ragionevoli per le `tlsNegotiationTimeoutInMillis` proprietà `connectTimeoutInMillis` and in base a un valore della modalità defaults fornito dall'utente. Scegliete il valore della modalità predefinita in base alle caratteristiche dell'applicazione.
[Per ulteriori informazioni sulle impostazioni predefinite di configurazione intelligente e su come scegliere il valore della modalità predefinita più adatto alle applicazioni, consulta la and Tools Reference Guide.AWS SDKs ](https://docs.aws.amazon.com/sdkref/latest/guide/feature-smart-config-defaults.html)
Di seguito sono riportati quattro modi per impostare la modalità predefinita per l'applicazione.
------
#### [ Service client ]
Utilizzate il service client builder per configurare la modalità predefinita direttamente sul client del servizio. L'esempio seguente imposta la modalità predefinita su. `auto` `DynamoDbClient`
```
DynamoDbClient ddbClient = DynamoDbClient.builder()
.defaultsMode(DefaultsMode.AUTO)
.build();
```
------
#### [ System property ]
È possibile utilizzare la proprietà `aws.defaultsMode` di sistema per specificare la modalità predefinita. Se si imposta la proprietà di sistema in Java, è necessario impostare la proprietà prima di inizializzare qualsiasi client di servizio.
L'esempio seguente mostra come impostare la modalità di default sull'`auto`utilizzo di una proprietà di sistema impostata in Java.
```
System.setProperty("aws.defaultsMode", "auto");
```
L'esempio seguente mostra come impostare la modalità di default per l'`auto`utilizzo di un'`-D`opzione del comando. `java`
```
java -Daws.defaultsMode=auto
```
------
#### [ Environment variable ]
Imposta un valore per la variabile di ambiente `AWS_DEFAULTS_MODE` per selezionare la modalità predefinita per l'applicazione.
Le informazioni seguenti mostrano il comando da eseguire per impostare il valore della modalità predefinita sull'`auto`utilizzo di una variabile di ambiente.
| Sistema operativo | Comando per impostare le variabili di ambiente |
| --- | --- |
| Linux, macOS o Unix | export AWS\$1DEFAULTS\$1MODE=auto |
| Windows | set AWS\$1DEFAULTS\$1MODE=auto |
------
#### [ AWS config file ]
È possibile aggiungere una proprietà di `defaults_mode` configurazione al AWS `config` file condiviso come illustrato nell'esempio seguente.
```
[default]
defaults_mode = auto
```
------
Se impostate la modalità predefinita a livello globale con la proprietà di sistema, la variabile di ambiente o il file di AWS configurazione, potete sovrascrivere le impostazioni quando create un client HTTP.
Quando create un client HTTP con il `httpClientBuilder()` metodo, le impostazioni si applicano solo all'istanza che state creando. Un esempio di ciò è mostrato [qui](http-configuration-netty.md#http-config-netty-one-client). Il client HTTP basato su Netty in questo esempio sostituisce tutti i valori di modalità predefiniti impostati globalmente per and. `connectTimeoutInMillis` `tlsNegotiationTimeoutInMillis`
# Configurare il client HTTP basato su Apache
Per impostazione predefinita, i client di servizio sincroni AWS SDK for Java 2.x utilizzano un client HTTP basato su Apache. [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html) L'SDK è basato su `ApacheHttpClient` Apache. [HttpClient](https://hc.apache.org/httpcomponents-client-4.5.x/index.html)
L'SDK offre anche il [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html), che si carica più rapidamente, ma ha meno funzionalità. Per informazioni sulla configurazione di`UrlConnectionHttpClient`, consulta. [Configurare il client HTTP URLConnection basato](http-configuration-url.md)
[Per visualizzare il set completo di opzioni di configurazione disponibili per`ApacheHttpClient`, consulta [ApacheHttpClient.Builder e .Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html). ProxyConfiguration](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ProxyConfiguration.Builder.html)
## Accedi a `ApacheHttpClient`
Nella maggior parte dei casi, si utilizza `ApacheHttpClient` senza alcuna configurazione esplicita. Dichiari i tuoi client di servizio e l'SDK li configurerà automaticamente `ApacheHttpClient` con valori standard.
Se desideri configurarlo in modo esplicito `ApacheHttpClient` o utilizzarlo con più client di servizio, devi renderlo disponibile per la configurazione.
### Non è necessaria alcuna configurazione
Quando si dichiara una dipendenza da un client di servizio in Maven, l'SDK aggiunge una dipendenza di *runtime* dall'artefatto. `apache-client` Ciò rende la `ApacheHttpClient` classe disponibile per il codice in fase di esecuzione, ma non in fase di compilazione. Se non state configurando il client HTTP basato su Apache, non è necessario specificare una dipendenza per esso.
Nel seguente frammento XML di un `pom.xml` file Maven, la dipendenza dichiarata con introduce automaticamente il client HTTP basato su Apache. `s3` Non è necessario dichiarare una dipendenza specifica per questo.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
```
Con queste dipendenze, non è possibile apportare modifiche esplicite alla configurazione HTTP, poiché la `ApacheHttpClient` libreria si trova solo nel classpath di runtime.
### Configurazione necessaria
*Per configurare`ApacheHttpClient`, è necessario aggiungere una dipendenza dalla libreria in fase di compilazione`apache-client`.*
Fate riferimento al seguente esempio di `pom.xml` file Maven per configurare. `ApacheHttpClient`
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache-client
```
## Usa e configura il `ApacheHttpClient`
È possibile configurare un'istanza `ApacheHttpClient` insieme alla creazione di un client di servizio oppure configurare una singola istanza da condividere tra più client di servizio.
Con entrambi gli approcci, si utilizza `[ApacheHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.Builder.html)` per configurare le proprietà per il client HTTP basato su Apache.
### Procedura consigliata: dedicare un'`ApacheHttpClient`istanza a un client di servizio
Se devi configurare un'istanza di`ApacheHttpClient`, ti consigliamo di creare l'`ApacheHttpClient`istanza dedicata. Puoi farlo utilizzando il `httpClientBuilder` metodo del builder del client del servizio. In questo modo, il ciclo di vita del client HTTP viene gestito dall'SDK, che aiuta a evitare potenziali perdite di memoria se l'`ApacheHttpClient`istanza non viene chiusa quando non è più necessaria.
L'esempio seguente crea `S3Client` e configura l'istanza incorporata di with and values. `ApacheHttpClient` `maxConnections` `connectionTimeout` L'istanza HTTP viene creata utilizzando il `httpClientBuilder` metodo di`S3Client.Builder`.
**Importazioni**
```
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Codice**
```
S3Client s3Client = S3Client // Singleton: Use the s3Client for all requests.
.builder()
.httpClientBuilder(ApacheHttpClient.builder()
.maxConnections(100)
.connectionTimeout(Duration.ofSeconds(5))
).build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close all service clients.
```
### Approccio alternativo: condividere un'`ApacheHttpClient`istanza
Per ridurre l'utilizzo di risorse e memoria per l'applicazione, è possibile configurarne un'applicazione `ApacheHttpClient` e condividerla tra più client di servizio. Il pool di connessioni HTTP verrà condiviso, il che riduce l'utilizzo delle risorse.
**Nota**
Quando un'`ApacheHttpClient`istanza è condivisa, è necessario chiuderla quando è pronta per essere eliminata. L'SDK non chiuderà l'istanza quando il client del servizio viene chiuso.
L'esempio seguente configura un client HTTP basato su Apache utilizzato da due client di servizio. L'`ApacheHttpClient`istanza configurata viene passata al `httpClient` metodo di ogni builder. Quando i client di servizio e il client HTTP non sono più necessari, il codice li chiude esplicitamente. Il codice chiude per ultimo il client HTTP.
**Importazioni**
```
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;
```
**Codice**
```
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.maxConnections(100).build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(apacheHttpClient).build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(apacheHttpClient).build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
apacheHttpClient.close(); // Explicitly close apacheHttpClient.
```
## Esempio di configurazione del proxy
Il seguente frammento di codice utilizza il [generatore di configurazione proxy per il client HTTP Apache](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ProxyConfiguration.Builder.html).
```
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://example.com:1234"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.addNonProxyHost("host.example.com")
.build())
.build();
```
Le proprietà di sistema Java equivalenti per la configurazione del proxy sono mostrate nel seguente frammento di riga di comando.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
La configurazione equivalente che utilizza le variabili di ambiente è:
```
// Set the following environment variables.
// $ export HTTP_PROXY="http://username:password@example.com:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
**Nota**
Il client HTTP Apache attualmente non supporta le proprietà del sistema proxy HTTPS o la variabile di ambiente HTTPS\$1PROXY.
# Configurare il client HTTP URLConnection basato
AWS SDK for Java 2.x Offre un client `[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)` HTTP più leggero rispetto a quello predefinito. `ApacheHttpClient` `UrlConnectionHttpClient`È basato su Java. `[URLConnection](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/net/URLConnection.html)`
Si `UrlConnectionHttpClient` carica più rapidamente rispetto al client HTTP basato su Apache, ma ha meno funzionalità. Poiché si carica più rapidamente, è una [buona soluzione](lambda-optimize-starttime.md) per le funzioni Java. AWS Lambda
`UrlConnectionHttpClient`Ha diverse [opzioni configurabili](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) a cui puoi accedere.
**Nota**
Non `UrlConnectionHttpClient` supporta il metodo HTTP PATCH.
Alcune operazioni AWS API richiedono richieste PATCH. I nomi di queste operazioni di solito iniziano con`Update*`. Di seguito sono riportati alcuni esempi.
[Diverse `Update*` operazioni](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_Operations.html) nell' AWS Security Hub CSPM API e anche l'[BatchUpdateFindings](https://docs.aws.amazon.com/securityhub/1.0/APIReference/API_BatchUpdateFindings.html)operazione
Tutte le [`Update*`operazioni](https://docs.aws.amazon.com/apigateway/latest/api/API_UpdateAccount.html) API di Amazon API Gateway
Se puoi utilizzare il`UrlConnectionHttpClient`, consulta innanzitutto l'API Reference relativo a Servizio AWS quello che stai utilizzando. Verifica se le operazioni necessarie utilizzano l'operazione PATCH.
## Accedi al `UrlConnectionHttpClient`
Per configurare e utilizzare`UrlConnectionHttpClient`, dichiari una dipendenza dall'artefatto `url-connection-client` Maven nel tuo file. `pom.xml`
A differenza di`ApacheHttpClient`, non `UrlConnectionHttpClient` viene aggiunto automaticamente al progetto, quindi use deve dichiararlo specificamente.
Il seguente esempio di `pom.xml` file mostra le dipendenze necessarie per utilizzare e configurare il client HTTP.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
url-connection-client
```
## Usa e configura il `UrlConnectionHttpClient`
È possibile configurare un'istanza `UrlConnectionHttpClient` insieme alla creazione di un client di servizio oppure configurare una singola istanza da condividere tra più client di servizio.
Con entrambi gli approcci, si utilizza [UrlConnectionHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.Builder.html) per configurare le proprietà per il client HTTP URLConnection basato.
### Procedura consigliata: dedicare un'`UrlConnectionHttpClient`istanza a un client di servizio
Se devi configurare un'istanza di`UrlConnectionHttpClient`, ti consigliamo di creare l'`UrlConnectionHttpClient`istanza dedicata. Puoi farlo utilizzando il `httpClientBuilder` metodo del builder del client del servizio. In questo modo, il ciclo di vita del client HTTP viene gestito dall'SDK, che aiuta a evitare potenziali perdite di memoria se l'`UrlConnectionHttpClient`istanza non viene chiusa quando non è più necessaria.
L'esempio seguente crea `S3Client` e configura l'istanza incorporata di with and values. `UrlConnectionHttpClient` `socketTimeout` `proxyConfiguration` Il `proxyConfiguration` metodo accetta un'espressione lambda Java di tipo. ` Consumer<[ProxyConfiguration.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html)>`
**Importazioni**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
import java.net.URI;
import java.time.Duration;
```
**Codice**
```
// Singleton: Use the s3Client for all requests.
S3Client s3Client =
S3Client.builder()
.httpClientBuilder(UrlConnectionHttpClient.builder()
.socketTimeout(Duration.ofMinutes(5))
.proxyConfiguration(proxy -> proxy.endpoint(URI.create("http://proxy.mydomain.net:8888"))))
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close the s3client.
```
### Approccio alternativo: condividi un'istanza `UrlConnectionHttpClient`
Per ridurre l'utilizzo di risorse e memoria per l'applicazione, è possibile configurarne un'applicazione `UrlConnectionHttpClient` e condividerla tra più client di servizio. Il pool di connessioni HTTP verrà condiviso, il che riduce l'utilizzo delle risorse.
**Nota**
Quando un'`UrlConnectionHttpClient`istanza è condivisa, è necessario chiuderla quando è pronta per essere eliminata. L'SDK non chiuderà l'istanza quando il client del servizio viene chiuso.
L'esempio seguente configura un client HTTP URLConnection basato che viene utilizzato da due client di servizio. L'`UrlConnectionHttpClient`istanza configurata viene passata al `httpClient` metodo di ogni builder. Quando i client di servizio e il client HTTP non sono più necessari, il codice li chiude esplicitamente. Il codice chiude per ultimo il client HTTP.
**Importazioni**
```
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.urlconnection.ProxyConfiguration;
import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.net.URI;
import java.time.Duration;
```
**Codice**
```
SdkHttpClient urlHttpClient = UrlConnectionHttpClient.create();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(urlHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(urlHttpClient)
.defaultsMode(DefaultsMode.IN_REGION)
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
urlHttpClient.close();
```
#### Usa `URLConnectionHttpClient` e insieme `ApacheHttpClient`
Quando si utilizza il `UrlConnectionHttpClient` nella propria applicazione, è necessario fornire a ciascun client di servizio un'`URLConnectionHttpClient`istanza o un'`ApacheHttpClient`istanza utilizzando il `httpClientBuilder` metodo del service client builder.
Si verifica un'eccezione se il programma utilizza più client di servizio ed entrambe le seguenti condizioni sono vere:
+ Un client di servizio è configurato per utilizzare un'`UrlConnectionHttpClient`istanza
+ Un altro client di servizio utilizza l'impostazione predefinita `ApacheHttpClient` senza crearla esplicitamente con i metodi `httpClient()` o `httpClientBuilder()`
L'eccezione indicherà che nel classpath sono state trovate più implementazioni HTTP.
Il seguente frammento di codice di esempio porta a un'eccezione.
```
// The dynamoDbClient uses the UrlConnectionHttpClient
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(UrlConnectionHttpClient.create())
.build();
// The s3Client below uses the ApacheHttpClient at runtime, without specifying it.
// An SdkClientException is thrown with the message that multiple HTTP implementations were found on the classpath.
S3Client s3Client = S3Client.create();
// Perform work with the s3Client and dynamoDbClient.
dynamoDbClient.close();
s3Client.close();
```
Evita l'eccezione configurando esplicitamente il con un. `S3Client` `ApacheHttpClient`
```
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(UrlConnectionHttpClient.create())
.build();
S3Client s3Client = S3Client.builder()
.httpClient(ApacheHttpClient.create()) // Explicitly build the ApacheHttpClient.
.build();
// Perform work with the s3Client and dynamoDbClient.
dynamoDbClient.close();
s3Client.close();
```
**Nota**
Per creare esplicitamente il`ApacheHttpClient`, è necessario [aggiungere una dipendenza dall'](http-configuration-apache.md#http-apache-dependency)`apache-client`artefatto nel file di progetto Maven.
## Esempio di configurazione del proxy
Il seguente frammento di codice utilizza il [generatore di configurazione proxy per il client HTTP di connessione URL.](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/ProxyConfiguration.Builder.html)
```
SdkHttpClient urlHttpClient = UrlConnectionHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://example.com:1234"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.addNonProxyHost("host.example.com")
.build())
.build();
```
Le proprietà di sistema Java equivalenti per la configurazione del proxy sono mostrate nel seguente frammento di riga di comando.
```
$ java -Dhttp.proxyHost=example.com -Dhttp.proxyPort=1234 -Dhttp.proxyUser=username \
-Dhttp.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
La configurazione equivalente che utilizza le variabili di ambiente è:
```
// Set the following environment variables.
// $ export HTTP_PROXY="http://username:password@example.com:1234"
// $ export NO_PROXY="localhost|host.example.com"
// Set the 'useSystemPropertyValues' to false on the proxy configuration.
SdkHttpClient apacheHttpClient = UrlConnectionHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build();
// Run the application.
// $ java -cp ... App
```
**Nota**
Il client HTTP URLConnection basato attualmente non supporta le proprietà del sistema proxy HTTPS o la variabile di ambiente HTTPS\$1PROXY.
# Configurazione del client HTTP basato su Netty
Il client HTTP predefinito per le operazioni asincrone in è basato su Netty. AWS SDK for Java 2.x [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) [Il client basato su Netty si basa sul framework di rete asincrono basato sugli eventi del progetto Netty.](https://netty.io/)
[Come client HTTP alternativo, è possibile utilizzare il nuovo client HTTP basato su CRT.AWS](http-configuration-crt.md) In questo argomento viene illustrato come configurare. `NettyNioAsyncHttpClient`
## Accedere a `NettyNioAsyncHttpClient`
Nella maggior parte dei casi, si utilizza la `NettyNioAsyncHttpClient` senza alcuna configurazione esplicita nei programmi asincroni. Dichiari i tuoi client di servizio asincroni e l'SDK li configurerà automaticamente con valori standard. `NettyNioAsyncHttpClient`
Se desideri configurarli in modo esplicito `NettyNioAsyncHttpClient` o utilizzarli con più client di servizio, devi renderli disponibili per la configurazione.
### Non è necessaria alcuna configurazione
Quando si dichiara una dipendenza da un client di servizio in Maven, l'SDK aggiunge una dipendenza di *runtime* dall'artefatto. `netty-nio-client` Ciò rende la `NettyNioAsyncHttpClient` classe disponibile per il codice in fase di esecuzione, ma non in fase di compilazione. Se non state configurando il client HTTP basato su Netty, non è necessario specificare una dipendenza per esso.
Nel seguente frammento XML di un `pom.xml` file Maven, la dipendenza dichiarata con richiama in modo transitivo il client HTTP basato su Netty. `dynamodb-enhanced` Non è necessario dichiarare una dipendenza specifica per questo.
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
```
Con queste dipendenze, non è possibile apportare modifiche alla configurazione HTTP, poiché la `NettyNioAsyncHttpClient` libreria si trova solo nel classpath di runtime.
### Configurazione necessaria
*Per configurare`NettyNioAsyncHttpClient`, è necessario aggiungere una dipendenza dall'`netty-nio-client`artefatto in fase di compilazione.*
Fate riferimento al seguente esempio di file `pom.xml` Maven per configurare. `NettyNioAsyncHttpClient`
```
software.amazon.awssdk
bom
2.27.21
pom
import
software.amazon.awssdk
dynamodb-enhanced
software.amazon.awssdk
netty-nio-client
```
## Usa e configura il `NettyNioAsyncHttpClient`
È possibile configurare un'istanza `NettyNioAsyncHttpClient` insieme alla creazione di un client di servizio oppure configurare una singola istanza da condividere tra più client di servizio.
Con entrambi gli approcci, si utilizza [NettyNioAsyncHttpClient.Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html) per configurare le proprietà per l'istanza del client HTTP basata su Netty.
### Procedura consigliata: dedicare un'`NettyNioAsyncHttpClient`istanza a un client di servizio
Se devi configurare un'istanza di`NettyNioAsyncHttpClient`, ti consigliamo di creare un'`NettyNioAsyncHttpClient`istanza dedicata. Puoi farlo utilizzando il `httpClientBuilder` metodo del builder del client del servizio. In questo modo, il ciclo di vita del client HTTP viene gestito dall'SDK, che aiuta a evitare potenziali perdite di memoria se l'`NettyNioAsyncHttpClient`istanza non viene chiusa quando non è più necessaria.
L'esempio seguente crea un'`DynamoDbAsyncClient`istanza che viene utilizzata da un'istanza. `DynamoDbEnhancedAsyncClient` L'`DynamoDbAsyncClient`istanza contiene l'`NettyNioAsyncHttpClient`istanza con `connectionTimeout` e `maxConcurrency` valori. L'istanza HTTP viene creata utilizzando `httpClientBuilder` il metodo di`DynamoDbAsyncClient.Builder`.
**Importazioni**
```
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;
```
**Codice**
```
// 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();
```
### Approccio alternativo: condividi un'`NettyNioAsyncHttpClient`istanza
Per ridurre l'utilizzo di risorse e memoria per l'applicazione, è possibile configurare un'applicazione `NettyNioAsyncHttpClient` e condividerla tra più client di servizio. Il pool di connessioni HTTP verrà condiviso, il che riduce l'utilizzo delle risorse.
**Nota**
Quando un'`NettyNioAsyncHttpClient`istanza è condivisa, è necessario chiuderla quando è pronta per essere eliminata. L'SDK non chiuderà l'istanza quando il client del servizio viene chiuso.
L'esempio seguente configura un client HTTP basato su Netty utilizzato da due client di servizio. L'`NettyNioAsyncHttpClient`istanza configurata viene passata al `httpClient` metodo di ogni builder. Quando i client di servizio e il client HTTP non sono più necessari, il codice li chiude esplicitamente. Il codice chiude per ultimo il client HTTP.
**Importazioni**
```
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;
```
**Codice**
```
// 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.
```
## Configura la negoziazione del protocollo ALPN
ALPN (Application-Layer Protocol Negotiation) è un'estensione TLS che consente al livello dell'applicazione di negoziare quale protocollo deve essere eseguito su una connessione sicura in modo da evitare ulteriori round trip e offrire prestazioni migliori.
Per consentire al client HTTP basato su Netty di utilizzare ALPN, chiamate i metodi builder come illustrato nel seguente frammento:
```
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();
```
La negoziazione del protocollo ALPN attualmente funziona solo con il protocollo HTTP/2, come mostrato nello snippet precedente.
## Esempio di configurazione del proxy
Il seguente frammento di codice utilizza il [generatore di configurazione proxy per il client 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();
```
Le proprietà di sistema Java equivalenti per la configurazione del proxy sono mostrate nel seguente frammento di riga di comando.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**Importante**
Per utilizzare una qualsiasi delle proprietà del sistema proxy HTTPS, la `scheme` proprietà deve essere impostata nel codice su. `https` Se la proprietà scheme non è impostata nel codice, per impostazione predefinita lo schema è HTTP e l'SDK cerca `http.*` solo le proprietà di sistema.
La configurazione equivalente che utilizza le variabili di 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
```
# Configurazione AWS dei client HTTP basati su CRT
I client HTTP AWS basati su CRT includono quelli sincroni e asincroni. [AwsCrtHttpClient[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html) I client HTTP AWS basati su CRT offrono i seguenti vantaggi del client HTTP:
+ Tempo di avvio del’SDK più rapido
+ Ingombro di memoria minore
+ Tempo di latenza ridotto
+ Gestione dell’integrità delle connessioni
+ Bilanciamento del carico DNS
**AWS Componenti basati su CRT nell'SDK**
I client *HTTP AWS * basati su CRT, descritti in questo argomento, e il client *S3 AWS basato su CRT sono componenti diversi dell'SDK*.
I client HTTP sincroni e asincroni **AWS basati su CRT sono interfacce client HTTP SDK di implementazione e vengono utilizzati per comunicazioni HTTP** generali. Sono alternative agli altri client HTTP sincroni o asincroni dell'SDK con vantaggi aggiuntivi.
Il **[client S3 AWS basato su CRT](crt-based-s3-client.md)** è un'implementazione dell'AsyncClientinterfaccia [S3](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) e viene utilizzato per lavorare con il servizio Amazon S3. È un'alternativa all'implementazione dell'interfaccia basata su Java e offre diversi vantaggi. `S3AsyncClient`
Sebbene entrambi i componenti utilizzino librerie del [AWS Common Runtime](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html), i client HTTP AWS basati su CRT non utilizzano la [libreria aws-c-s 3](https://github.com/awslabs/aws-c-s3) e non supportano le funzionalità dell'API di caricamento multipart di [S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html). Il client S3 AWS basato su CRT, invece, è stato creato appositamente per supportare le funzionalità dell'API di caricamento multiparte di S3.
## Accedi AWS ai client HTTP basati su CRT
Prima di poter utilizzare i client HTTP AWS basati su CRT, aggiungete l'`aws-crt-client`artefatto con una versione minima di 2.22.0 alle dipendenze del progetto.
Usa una delle seguenti opzioni per configurare il tuo file Maven. `pom.xml`
**Nota**
È possibile scegliere di utilizzare l'*opzione jar specifica della piattaforma* se è necessario ridurre le dimensioni delle dipendenze di runtime, ad esempio se l'applicazione viene eseguita in una funzione. AWS Lambda
------
#### [ Uber-jar option ]
Per impostazione predefinita, `aws-crt-client` utilizza un uber-jar di artefatti AWS CRT che contiene file binari per diverse piattaforme, tra cui Linux, Windows e macOS.
```
2.29.10*
software.amazon.awssdk
bom
${aws.sdk.version}
pom
import
software.amazon.awssdk
aws-crt-client
```
\$1Sostituisci la versione mostrata in rosso con la versione di Java SDK che desideri utilizzare. Trova le ultime novità su [Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) Central.
------
#### [ Platform-specific jar option ]
*Per limitare il runtime Java alla versione specifica della piattaforma della libreria AWS CRT, apporta le seguenti modifiche all'opzione Uber-JAR.*
+ Aggiungi un `exclusions` elemento all'artefatto dell'SDK. `aws-crt-client` Questa esclusione impedisce all'SDK di utilizzare transitivamente il CRT uber-jar. AWS
+ Aggiungi un elemento di dipendenza per la versione specifica della piattaforma CRT di cui hai bisogno. AWS **Consultate i passaggi per determinare la versione dell'artefatto AWS CRT di seguito per sapere come determinare la versione** corretta.
```
2.29.101
software.amazon.awssdk
bom
${aws.sdk.java.version}
pom
import
software.amazon.awssdk
aws-crt-client
software.amazon.awssdk.crt
aws-crt
software.amazon.awssdk.crt
aws-crt
0.31.32
linux-x86_643
```
1 Sostituisci la versione mostrata in rosso con la versione di Java SDK che desideri utilizzare. Trova le ultime novità su [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).
2 Sostituisci la versione `software.amazon.awssdk.crt:aws-crt` che sarebbe fornita dall'opzione *Uber-JAR*. Vedi i seguenti **passaggi per determinare la versione dell'artefatto AWS CRT**.
3 Sostituisci il `classifier` valore con uno per la tua piattaforma. Fate riferimento alla GitHub pagina AWS CRT per Java per un [elenco dei valori disponibili](https://github.com/awslabs/aws-crt-java?tab=readme-ov-file#platform-specific-jars).
**Passaggi per determinare la versione dell' AWS artefatto CRT**
Utilizzate i seguenti passaggi per determinare la versione dell'artefatto AWS CRT compatibile con la versione dell'SDK for Java in uso.
1. *Configura il `pom.xml` file come mostrato nell'opzione Uber-JAR.* Questa configurazione ti consente di vedere quale versione dell'SDK `software.amazon.awssdk.crt:aws-crt` è disponibile per impostazione predefinita.
1. Alla radice del progetto (nella stessa directory del `pom.xml` file), esegui il seguente comando Maven:
```
mvn dependency:tree -Dincludes=software.amazon.awssdk.crt:aws-crt
```
Maven potrebbe eseguire altre azioni, ma alla fine dovresti vedere l'output della console della `software.amazon.awssdk.crt:aws-crt` dipendenza utilizzata dall'SDK in modo transitivo. Il seguente frammento mostra un output di esempio basato su una versione SDK di: `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
```
1. Usa la versione mostrata dalla console per l'artefatto. `software.amazon.awssdk.crt:aws-crt` In questo caso, aggiungilo `0.31.3` al tuo `pom.xml` file.
------
## Usa e configura un client HTTP AWS basato su CRT
È possibile configurare un client HTTP AWS basato su CRT insieme alla creazione di un client di servizio oppure è possibile configurare una singola istanza da condividere tra più client di servizio.
Con entrambi gli approcci, si utilizza un builder per [configurare le proprietà per l'istanza del client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.Builder.html) HTTP basato su AWS CRT.
### Procedura consigliata: dedicare un'istanza a un client di servizio
Se devi configurare un'istanza di un client HTTP AWS basato su CRT, ti consigliamo di dedicare l'istanza costruendola insieme al client di servizio. Puoi farlo utilizzando il `httpClientBuilder` metodo del builder del client del servizio. In questo modo, il ciclo di vita del client HTTP viene gestito dall'SDK, che aiuta a evitare potenziali perdite di memoria se l'istanza del client HTTP AWS basato su CRT non viene chiusa quando non è più necessaria.
L'esempio seguente crea un client di servizio S3 e configura un client HTTP basato su CRT con valori e. AWS `connectionTimeout` `maxConcurrency`
------
#### [ Synchronous client ]
**Importazioni**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Codice**
```
// 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 ]
**Importazioni**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Codice**
```
// 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();
```
------
### Approccio alternativo: condividi un'istanza
Per ridurre l'utilizzo di risorse e memoria per l'applicazione, è possibile configurare un client HTTP AWS basato su CRT e condividerlo tra più client di servizio. Il pool di connessioni HTTP verrà condiviso, il che riduce l'utilizzo delle risorse.
**Nota**
Quando un'istanza client HTTP AWS basata su CRT viene condivisa, è necessario chiuderla quando è pronta per essere eliminata. L'SDK non chiuderà l'istanza quando il client del servizio viene chiuso.
L'esempio seguente configura un'istanza client HTTP AWS basata su CRT con valori e. `connectionTimeout` `maxConcurrency` L'istanza configurata viene passata al `httpClient` metodo del builder di ogni client di servizio. Quando i client di servizio e il client HTTP non sono più necessari, vengono chiusi in modo esplicito. Il client HTTP viene chiuso per ultimo.
------
#### [ Synchronous client ]
**Importazioni**
```
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;
```
**Codice**
```
// 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 ]
**Importazioni**
```
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;
```
**Codice**
```
// 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.
```
------
## Imposta un client HTTP AWS basato su CRT come predefinito
Puoi configurare il tuo file di build Maven in modo che l'SDK utilizzi un client HTTP AWS basato su CRT come client HTTP predefinito per i client di servizio.
A tale scopo, è possibile aggiungere un `exclusions` elemento con le dipendenze del client HTTP predefinite a ciascun elemento del client di servizio.
Nell'`pom.xml`esempio seguente, l'SDK utilizza un client HTTP AWS basato su CRT per i servizi S3. Se il client di servizio nel codice è un`S3AsyncClient`, l'SDK lo utilizza. `AwsCrtAsyncHttpClient` Se il client di servizio è un S3Client, l'SDK utilizza. `AwsCrtHttpClient` Con questa configurazione il client HTTP asincrono predefinito basato su Netty e l'HTTP sincrono predefinito basato su Apache non sono disponibili.
```
VERSION
software.amazon.awssdk
s3
${aws.sdk.version}
software.amazon.awssdk
netty-nio-client
software.amazon.awssdk
apache-client
software.amazon.awssdk
aws-crt-client
```
Visita il repository centrale di Maven per le ultime novità. [https://central.sonatype.com/artifact/software.amazon.awssdk/bom](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
**Nota**
Se più client di servizio sono dichiarati in un `pom.xml` file, tutti richiedono l'`exclusions`elemento XML.
### Utilizzate una proprietà di sistema Java
Per utilizzare i client HTTP AWS basati su CRT come HTTP predefinito per l'applicazione, è possibile impostare la proprietà del sistema Java su un valore `software.amazon.awssdk.http.async.service.impl` di. `software.amazon.awssdk.http.crt.AwsCrtSdkHttpService`
Per impostarlo durante l'avvio dell'applicazione, eseguite un comando simile al seguente.
```
java app.jar -Dsoftware.amazon.awssdk.http.async.service.impl=\
software.amazon.awssdk.http.crt.AwsCrtSdkHttpService
```
Utilizzate il seguente frammento di codice per impostare la proprietà di sistema nel codice dell'applicazione.
```
System.setProperty("software.amazon.awssdk.http.async.service.impl",
"software.amazon.awssdk.http.crt.AwsCrtSdkHttpService");
```
**Nota**
È necessario aggiungere una dipendenza dall'elemento nel `poml.xml` file quando si utilizza una proprietà di sistema per configurare l'uso dei client HTTP basati su `aws-crt-client` CRT. AWS
## Configurazione avanzata dei client HTTP basati su CRT AWS
È possibile utilizzare varie impostazioni di configurazione dei client HTTP AWS basati su CRT, tra cui la configurazione dello stato della connessione e il tempo massimo di inattività. È possibile esaminare le [opzioni di configurazione disponibili per.](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.Builder.html) `AwsCrtAsyncHttpClient` È possibile configurare le stesse opzioni per`AwsCrtHttpClient`.
### Configurazione dello stato della connessione
È possibile configurare la configurazione dello stato della connessione per i client HTTP AWS basati su CRT utilizzando il `connectionHealthConfiguration` metodo del generatore di client HTTP.
L'esempio seguente crea un client di servizio S3 che utilizza un'istanza del client HTTP AWS basata su CRT configurata con la configurazione dello stato della connessione e un tempo di inattività massimo per le connessioni.
------
#### [ Synchronous client ]
**Importazioni**
```
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Codice**
```
// 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 ]
**Importazioni**
```
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import java.time.Duration;
```
**Codice**
```
// 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();
```
------
## Supporto HTTP/2
Il protocollo HTTP/2 non è ancora supportato nei client HTTP AWS basati su CRT, ma è previsto per una versione futura.
Nel frattempo, se utilizzi client di servizio che richiedono il supporto HTTP/2 come the o the, considera di utilizzare invece il [KinesisAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/kinesis/KinesisAsyncClient.html). [TranscribeStreamingAsyncClient[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/TranscribeStreamingAsyncClient.html)
## Esempio di configurazione del proxy
Il seguente frammento di codice mostra l'uso di [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/ProxyConfiguration.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/ProxyConfiguration.Builder.html)ciò che si utilizza per configurare l'impostazione del proxy nel codice.
------
#### [ Synchronous client ]
**Importazioni**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Codice**
```
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 ]
**Importazioni**
```
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.crt.AwsCrtAsyncHttpClient;
import software.amazon.awssdk.http.crt.ProxyConfiguration;
```
**Codice**
```
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();
```
------
Le proprietà di sistema Java equivalenti per la configurazione del proxy sono mostrate nel seguente frammento di riga di comando.
```
$ java -Dhttps.proxyHost=myproxy -Dhttps.proxyPort=1234 -Dhttps.proxyUser=username \
-Dhttps.proxyPassword=password -Dhttp.nonProxyHosts=localhost|host.example.com -cp ... App
```
**Importante**
Per utilizzare una qualsiasi delle proprietà del sistema proxy HTTPS, la `scheme` proprietà deve essere impostata nel codice su. `https` Se la proprietà scheme non è impostata nel codice, per impostazione predefinita lo schema è HTTP e l'SDK cerca `http.*` solo le proprietà di sistema.
La configurazione equivalente che utilizza le variabili di 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
```
# Configurazione dei proxy HTTP
È possibile configurare i proxy HTTP utilizzando il codice, impostando le proprietà del sistema Java o impostando le variabili di ambiente.
## Configura nel codice
I proxy vengono configurati in codice con un `ProxyConfiguration` builder specifico per il client quando si crea il client di servizio. Il codice seguente mostra un esempio di configurazione proxy per un client HTTP basato su Apache utilizzato da un client di servizio Amazon S3.
```
SdkHttpClient httpClient1 = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://proxy.example.com"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.build())
.build();
S3Client s3Client = S3Client.builder()
.httpClient(httpClient)
.build();
```
La sezione relativa a ciascun client HTTP di questo argomento mostra un esempio di configurazione proxy.
+ [Client Apache HTTP](http-configuration-apache.md#http-configuration-apache-proxy-conf-ex)
+ [URLConnectionclient HTTP basato su](http-configuration-url.md#http-configuration-url-proxy-conf-ex)
+ [client HTTP basato su Netty](http-configuration-netty.md#http-config-netty-proxy-ex)
+ [AWS Client HTTP basato su CRT](http-configuration-crt.md#http-config-crt-proxy-ex)
## Configura i proxy HTTP con impostazioni esterne
Anche se non utilizzi esplicitamente un `ProxyConfiguration` builder nel codice, l'SDK cerca le impostazioni esterne per configurare una configurazione proxy predefinita.
Per impostazione predefinita, l'SDK cerca innanzitutto le proprietà del sistema JVM. Se viene trovata anche una sola proprietà, l'SDK utilizza il valore e qualsiasi altro valore di proprietà di sistema. Se non sono disponibili proprietà di sistema, l'SDK cerca le variabili di ambiente proxy.
L'SDK può utilizzare le seguenti proprietà di sistema e variabili di ambiente Java.
**Proprietà del sistema Java**
| Proprietà del sistema | Description | Supporto client HTTP |
| --- | --- | --- |
| http.ProxyHost | Nome host del server proxy HTTP | Tutti |
| HTTP.ProxyPort | Numero di porta del server proxy HTTP | Tutti |
| http.proxyUser | Nome utente per l'autenticazione del proxy HTTP | Tutti |
| Http.ProxyPassword | Password per l'autenticazione del proxy HTTP | Tutti |
| http. nonProxyHosts | Elenco di host che devono essere raggiunti direttamente, ignorando il proxy. [Questo elenco è valido anche quando si utilizza HTTPS](https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html). | Tutti |
| https://proxyHost | Nome host del server proxy HTTPS | Netty, CRT |
| Porta https://proxy | Numero di porta del server proxy HTTPS | Netty, CRT |
| Utente https://proxy | Nome utente per l'autenticazione proxy HTTPS | Netty, CRT |
| Password https://proxy | Password per l'autenticazione del proxy HTTPS | Netty, CRT |
**Variabili di ambiente**
| Variabile di ambiente | Description | Supporto client HTTP |
| --- | --- | --- |
| HTTP\$1PROXY 1 | Un URL valido con uno schema HTTP | Tutti |
| HTTPS\$1PROXY 1 | Un URL valido con uno schema HTTPS | Netty, CRT |
| NO\$1PROXY 2 | Elenco di host che devono essere raggiunti direttamente, ignorando il proxy. L'elenco è valido sia per HTTP che per HTTPS. | Tutti |
### Visualizza la chiave e le note a piè di pagina
**Tutti**: tutti i client HTTP offerti dall'SDK—`UrlConnectionHttpClient`,,`ApacheHttpClient`,`NettyNioAsyncHttpClient`. `AwsCrtAsyncHttpClient`
**Netty**: il client HTTP basato su Netty (). `NettyNioAsyncHttpClient`
**CRT** - I client HTTP AWS basati su CRT, (e). `AwsCrtHttpClient` `AwsCrtAsyncHttpClient`
1 La variabile di ambiente richiesta, indipendentemente dal fatto che sia `HTTP_PROXY` o meno`HTTPS_PROXY`, dipende dall'impostazione dello schema nel client. `ProxyConfiguration` Lo schema predefinito è HTTP. Il seguente frammento mostra come modificare lo schema in HTTPS utilizzato per la risoluzione delle variabili di ambiente.
```
SdkHttpClient httpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.build())
.build();
```
2 La variabile di `NO_PROXY` ambiente supporta una combinazione di separatori «\$1» e «,» tra i nomi host. I nomi host possono includere il carattere jolly «\$1».
## Usa una combinazione di impostazioni
È possibile utilizzare una combinazione di impostazioni del proxy HTTP nel codice, nelle proprietà di sistema e nelle variabili di ambiente.
**Example — configurazione fornita da una proprietà di sistema e dal codice**
```
// Command line with the proxy password set as a system property.
$ java -Dhttp.proxyPassword=SYS_PROP_password -cp ... App
// Since the 'useSystemPropertyValues' setting is 'true' (the default), the SDK will supplement
// the proxy configuration in code with the 'http.proxyPassword' value from the system property.
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://localhost:1234"))
.username("username")
.build())
.build();
// Use the apache HTTP client with proxy configuration.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(apacheHttpClient)
.build();
```
L'SDK risolve le seguenti impostazioni proxy.
```
Host = localhost
Port = 1234
Password = SYS_PROP_password
UserName = username
Non ProxyHost = null
```
**Example — sono disponibili sia le proprietà di sistema che le variabili di ambiente**
Il `ProxyConfiguration` builder di ogni client HTTP offre impostazioni denominate `useSystemPropertyValues` e`useEnvironmentVariablesValues`. Per impostazione predefinita, entrambe le impostazioni sono`true`. Quando`true`, l'SDK utilizza automaticamente i valori delle proprietà di sistema o delle variabili di ambiente per opzioni non fornite dal `ProxyConfiguration` builder.
Le proprietà di sistema hanno la precedenza sulle variabili di ambiente. Se viene trovata una proprietà del sistema proxy HTTP, l'SDK recupera ***tutti i*** valori dalle proprietà di sistema e nessuno dalle variabili di ambiente. Se desideri dare priorità alle variabili di ambiente rispetto alle proprietà di sistema, imposta su. `useSystemPropertyValues` `false`
Per questo esempio, le seguenti impostazioni sono disponibili in fase di esecuzione:
```
// System properties
http.proxyHost=SYS_PROP_HOST.com
http.proxyPort=2222
http.password=SYS_PROP_PASSWORD
http.user=SYS_PROP_USER
// Environment variables
HTTP_PROXY="http://EnvironmentUser:EnvironmentPassword@ENV_VAR_HOST:3333"
NO_PROXY="environmentnonproxy.host,environmentnonproxy2.host:1234"
```
Il client di servizio viene creato con una delle seguenti istruzioni. Nessuna delle istruzioni imposta esplicitamente un'impostazione proxy.
```
DynamoDbClient client = DynamoDbClient.create();
DynamoDbClient client = DynamoDbClient.builder().build();
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.build())
.build())
.build();
```
Le seguenti impostazioni proxy vengono risolte dall'SDK:
```
Host = SYS_PROP_HOST.com
Port = 2222
Password = SYS_PROP_PASSWORD
UserName = SYS_PROP_USER
Non ProxyHost = null
```
Poiché il client del servizio dispone di impostazioni proxy predefinite, l'SDK cerca le proprietà del sistema e quindi le variabili di ambiente. Poiché le impostazioni delle proprietà di sistema hanno la precedenza sulle variabili di ambiente, l'SDK utilizza solo le proprietà di sistema.
Se l'uso delle proprietà di sistema viene modificato `false` come mostrato nel codice seguente, l'SDK risolve solo le variabili di ambiente.
```
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build())
.build();
```
Le impostazioni proxy risolte tramite HTTP sono:
```
Host = ENV_VAR_HOST
Port = 3333
Password = EnvironmentPassword
UserName = EnvironmentUser
Non ProxyHost = environmentnonproxy.host, environmentnonproxy2.host:1234
```
# Configurazione del client HTTP basato su Apache 5.x
## Accedi ad Apache 5 HttpClient
Per utilizzare il, `Apache5HttpClient` è necessario aggiungere una dipendenza **apache5-client** e configurare `Apache5HttpClient` in modo esplicito i client di servizio.
```
software.amazon.awssdk
bom
2.41.0*
pom
import
software.amazon.awssdk
s3
software.amazon.awssdk
apache5-client
```
\$1Sostituisci la versione mostrata in rosso con la versione di Java SDK che desideri utilizzare. Trova le ultime novità su [Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) Central.
### Usa e configura il `Apache5HttpClient`
È possibile configurare un'istanza `Apache5HttpClient` insieme alla creazione di un client di servizio oppure configurare una singola istanza da condividere tra più client di servizio.
Con entrambi gli approcci, si utilizza [Apache5 HttpClient .Builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.Builder.html) per configurare le proprietà del client HTTP basato su Apache 5.
#### Procedura consigliata: dedicare un'istanza Apache5 a un client di servizio HttpClient
Se devi configurare un'istanza di`Apache5HttpClient`, ti consigliamo di creare l'istanza dedicata. `Apache5HttpClient` Puoi farlo utilizzando il httpClientBuilder metodo del builder del client del servizio. In questo modo, il ciclo di vita del client HTTP viene gestito dall'SDK, che aiuta a evitare potenziali perdite di memoria se l'`Apache5HttpClient`istanza non viene chiusa quando non è più necessaria.
L'esempio seguente crea un S3Client e configura l'istanza incorporata di con i valori MaxConnections e ConnectionTimeout. `Apache5HttpClient` L'istanza HTTP viene creata utilizzando il metodo di. `httpClientBuilder` `S3Client.Builder`
**Importazioni**
```
import software.amazon.awssdk.http.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.s3.S3Client;
import java.time.Duration;
```
**Codice**
```
S3Client s3Client = S3Client // Singleton: Use the s3Client for all requests.
.builder()
.httpClientBuilder(Apache5HttpClient.builder()
.maxConnections(100)
.connectionTimeout(Duration.ofSeconds(5))
)
.build();
// Perform work with the s3Client.
s3Client.close(); // Requests completed: Close all service clients.
```
#### Approccio alternativo: condividere un'`Apache5HttpClient`istanza
Per ridurre l'utilizzo di risorse e memoria per l'applicazione, è possibile configurarne un'applicazione `Apache5HttpClient` e condividerla tra più client di servizio. Il pool di connessioni HTTP verrà condiviso, il che riduce l'utilizzo delle risorse.
**Nota**
Quando un'`Apache5HttpClient`istanza è condivisa, è necessario chiuderla quando è pronta per essere eliminata. L'SDK non chiuderà l'istanza quando il client del servizio viene chiuso.
L'esempio seguente configura un client HTTP basato su Apache utilizzato da due client di servizio. L'`ApacheHttpClient`istanza configurata viene passata al metodo HttpClient di ogni builder. Quando i client di servizio e il client HTTP non sono più necessari, il codice li chiude esplicitamente. Il codice chiude per ultimo il client HTTP.
**Importazioni**
```
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.apache5.Apache5HttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.s3.S3Client;
```
**Codice**
```
SdkHttpClient apache5HttpClient = Apache5HttpClient.builder()
.maxConnections(100).build();
// Singletons: Use the s3Client and dynamoDbClient for all requests.
S3Client s3Client =
S3Client.builder()
.httpClient(apache5HttpClient).build();
DynamoDbClient dynamoDbClient =
DynamoDbClient.builder()
.httpClient(apache5HttpClient).build();
// Perform work with the s3Client and dynamoDbClient.
// Requests completed: Close all service clients.
s3Client.close();
dynamoDbClient.close();
apache5HttpClient.close(); // Explicitly close apache5HttpClient.
```