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à.
# Usando il AWS SDK for Java 2.x
Questo capitolo mostra come utilizzarlo in AWS SDK for Java 2.x modo efficace. Impara a creare clienti di servizio, effettuare richieste, gestire le risposte e gestire gli errori. Il capitolo tratta la programmazione sincrona e asincrona, i risultati impaginati, i tempi necessari per il monitoraggio delle risorse e l'ottimizzazione delle prestazioni.
Troverai anche le migliori pratiche per il riutilizzo dei client, linee guida per la risoluzione dei problemi, l'ottimizzazione dell'avvio Lambda, il supporto HTTP/2 e la configurazione DNS.
**Contents**
+ [Effettuare richieste utilizzando il Servizio AWS AWS SDK for Java 2.x](work-witih-clients.md)
+ [Utilizzo dei client di servizio per effettuare richieste](work-witih-clients.md#using-service-client)
+ [Crea un client di servizio](work-witih-clients.md#work-with-clients-create)
+ [Configurazione client predefinita](work-witih-clients.md#using-default-client)
+ [Configurare i client di servizio](work-witih-clients.md#using-configure-service-clients)
+ [Chiudere il client di servizio](work-witih-clients.md#using-closing-client)
+ [Effettua richieste](work-witih-clients.md#using-making-requests)
+ [Utilizzate le richieste per sovrascrivere la configurazione del client](work-witih-clients.md#using-override-client-config-request)
+ [Gestione delle risposte](work-witih-clients.md#using-handling-responses)
+ [Programmazione asincrona utilizzando il AWS SDK for Java 2.x](asynchronous.md)
+ [Usa un client asincrono APIs](asynchronous.md#basics-async-non-streaming)
+ [Gestisci lo streaming con metodi asincroni](asynchronous.md#basics-async-streaming)
+ [Configura opzioni asincrone avanzate](asynchronous.md#advanced-operations)
+ [Le migliori pratiche per l'utilizzo di AWS SDK for Java 2.x](best-practices.md)
+ [Impedisci il blocco delle richieste configurando i timeout delle API](best-practices.md#bestpractice5)
+ [Migliora le prestazioni riutilizzando i client di servizio](best-practices.md#bestpractice1)
+ [Previeni le fughe di risorse chiudendo i client di servizio inutilizzati](best-practices.md#bestpractice-close-client)
+ [Previeni l'esaurimento del pool di connessioni chiudendo i flussi di input](best-practices.md#bestpractice2)
+ [Ottimizza le prestazioni HTTP per il carico di lavoro delle tue applicazioni](best-practices.md#bestpractice3)
+ [Migliora le prestazioni SSL con OpenSSL per client asincroni](best-practices.md#bestpractice4)
+ [Monitora le prestazioni delle applicazioni con le metriche SDK](best-practices.md#bestpractice6)
+ [Gestione degli errori nel AWS SDK for Java 2.x](handling-exceptions.md)
+ [Perché le eccezioni non sono controllate?](handling-exceptions.md#why-unchecked-exceptions)
+ [AwsServiceException (e sottoclassi)](handling-exceptions.md#sdkserviceexception-and-subclasses)
+ [SdkClientException](handling-exceptions.md#sdkclientexception)
+ [Eccezioni e comportamento nei tentativi](handling-exceptions.md#retried-exceptions)
+ [Utilizzo dei risultati impaginati nella versione 2.x AWS SDK per Java](pagination.md)
+ [Impaginazione sincrona](pagination.md#synchronous-pagination)
+ [Iterate sulle pagine](pagination.md#iterate-pages)
+ [Iterate sugli oggetti](pagination.md#iterate-objects)
+ [Usa uno stream](pagination.md#use-a-stream)
+ [Usa un ciclo for-each](pagination.md#for-loop)
+ [Impaginazione manuale](pagination.md#manual-pagination)
+ [Impaginazione asincrona](pagination.md#asynchronous-pagination)
+ [Iterate su pagine di nomi di tabelle](pagination.md#iterate-pages-async)
+ [Usa un `Subscriber`](pagination.md#use-a-subscriber)
+ [Usa un `Consumer`](pagination.md#id1pagination)
+ [Esegui iterazioni sui nomi delle tabelle](pagination.md#iterate-objects-async)
+ [Usa un `Subscriber`](pagination.md#id2)
+ [Usa un `Consumer`](pagination.md#for-loop-async)
+ [Usa una libreria di terze parti](pagination.md#use-third-party-library)
+ [Usare i camerieri nel AWS SDK for Java 2.x](waiters.md)
+ [Prerequisiti](waiters.md#prerequisiteswaiters)
+ [Usare i camerieri](waiters.md#id1waiters)
+ [Programmazione sincrona](waiters.md#synchronous-programming)
+ [Programmazione asincrona](waiters.md#asynchronous-programming)
+ [Configura i camerieri](waiters.md#configuring-waiters)
+ [Configura un cameriere](waiters.md#configure-a-waiter)
+ [Sostituisci la configurazione per una richiesta specifica](waiters.md#override-configuration-for-a-specific-request)
+ [Esempi di codice](waiters.md#code-examples)
+ [Risoluzione dei problemi FAQs](troubleshooting.md)
+ [Come posso correggere l'errore "`java.net.SocketException`: ripristino della connessione» o «il server non è riuscito a completare la risposta»?](troubleshooting.md#faq-socketexception)
+ [Come posso correggere il «timeout della connessione»?](troubleshooting.md#faq-connection-timeout)
+ [Come posso risolvere il problema "`java.net.SocketTimeoutException`: Read timeout»?](troubleshooting.md#faq-socket-timeout)
+ [Come posso correggere l'errore «Impossibile eseguire la richiesta HTTP: timeout in attesa di connessione dal pool»?](troubleshooting.md#faq-pool-timeout)
+ [Come posso riparare un`NoClassDefFoundError`, or? `NoSuchMethodError` `NoSuchFieldError`](troubleshooting.md#faq-classpath-errors)
+ [Come posso correggere un errore "`SignatureDoesNotMatch`" o l'errore «La firma della richiesta che abbiamo calcolato non corrisponde alla firma che hai fornito»?](troubleshooting.md#faq-signature-does-not-match-error)
+ [Come posso correggere l'errore "`java.lang.IllegalStateException`: Connection pool shut down»?](troubleshooting.md#faq-connection-pool-shutdown-exception)
+ [Come posso risolvere il problema «Impossibile caricare le credenziali da nessuno dei provider della catena «? AwsCredentialsProviderChain](troubleshooting.md#faq-credentials-provider-chain)
+ [Cause e soluzioni comuni](troubleshooting.md#faq-cred-provider-chain-common-causes-and-solutions)
+ [Rivedi la configurazione delle credenziali](troubleshooting.md#faq-cred-provider-chain-check-config)
+ [Per le istanze Amazon EC2](troubleshooting.md#faq-cred-check-ec2)
+ [Per ambienti container](troubleshooting.md#faq-cred-check-container-env)
+ [Per lo sviluppo locale](troubleshooting.md#faq-cred-check-local-dev)
+ [Per la federazione delle identità web](troubleshooting.md#faq-cred-check-web-id-federation)
+ [Problemi di connettività di rete o proxy](troubleshooting.md#faq-credentials-provider-chain-network-issues)
+ [Riduci i tempi di avvio dell'SDK per AWS Lambda](lambda-optimize-starttime.md)
+ [Utilizzate un client AWS HTTP basato su CRT](lambda-optimize-starttime.md#lambda-quick-url)
+ [Rimuovi le dipendenze inutilizzate del client HTTP](lambda-optimize-starttime.md#lambda-quick-remove-deps)
+ [Configura i client di servizio per abbreviare le ricerche](lambda-optimize-starttime.md#lambda-quick-clients)
+ [Inizializza il client SDK all'esterno del gestore di funzioni Lambda](lambda-optimize-starttime.md#lambda-quick-initialize)
+ [Riduci al minimo l'iniezione di dipendenza](lambda-optimize-starttime.md#lambda-quick-di)
+ [Usa un targeting Maven Archetype AWS Lambda](lambda-optimize-starttime.md#lambda-quick-maven)
+ [Prendi in considerazione Lambda SnapStart per Java](lambda-optimize-starttime.md#lambda-quick-snapstart)
+ [Modifiche alla versione 2.x che influiscono sul tempo di avvio](lambda-optimize-starttime.md#example-client-configuration)
+ [Risorse aggiuntive](lambda-optimize-starttime.md#lambda-quick-resources)
+ [Implementare `ContentStreamProvider` nel AWS SDK for Java 2.x](content-stream-provider.md)
+ [Uso di `mark()` e `reset()`](content-stream-provider.md#csp-impl-mark-reset)
+ [Usa il buffering se `mark()` e `reset()` non sono disponibili](content-stream-provider.md#csp-impl-unsupported-streams)
+ [Crea nuovi stream](content-stream-provider.md#csp-impl-new-stream)
+ [Imposta il TTL JVM per le ricerche dei nomi DNS](jvm-ttl-dns.md)
+ [Come impostare il TTL JVM](jvm-ttl-dns.md#how-to-set-the-jvm-ttl)
+ [Opzione 1: impostala a livello di codice nella tua applicazione](jvm-ttl-dns.md#set-ttl-programmatically)
+ [Opzione 2: impostala nel file java.security](jvm-ttl-dns.md#set-ttl-java-security-file)
+ [Opzione 3: utilizzare il fallback delle proprietà del sistema JDK (riga di comando)](jvm-ttl-dns.md#set-ttl-system-property)
+ [Lavora con HTTP/2 in AWS SDK per Java](http2.md)
# Effettuare richieste utilizzando il Servizio AWS AWS SDK for Java 2.x
## Utilizzo dei client di servizio per effettuare richieste
Dopo aver completato i passaggi descritti in [Configurazione dell'SDK](setup.md) e aver compreso come [configurare i client di servizio](configuring-service-clients.md), sei pronto per effettuare richieste a AWS servizi come Amazon S3, Amazon DynamoDB AWS Identity and Access Management, Amazon EC2 e altri.
### Crea un client di servizio
Per effettuare una richiesta a un Servizio AWS, devi prima creare un'istanza di un client di servizio per quel servizio utilizzando il metodo static factory,. `builder()` Il `builder()` metodo restituisce un `builder` oggetto che consente di personalizzare il client del servizio. I metodi setter fluent restituiscono l'oggetto `builder`. In questo modo puoi concatenare chiamate al metodo per comodità e per avere un codice più leggibile. Dopo aver configurato le proprietà desiderate, chiamate il `build()` metodo per creare il client.
Ad esempio, il seguente frammento di codice crea un'istanza di un `Ec2Client` oggetto come client di servizio per Amazon EC2.
```
Region region = Region.US_WEST_2;
Ec2Client ec2Client = Ec2Client.builder()
.region(region)
.build();
```
**Nota**
I client del servizio nell'SDK sono thread-safe. Per prestazioni ottimali, ti consigliamo di trattarli come oggetti di lunga durata. Ogni client dispone di una propria risorsa di pooling delle connessioni che viene rilasciata durante il processo di garbage collection del client.
Un oggetto client di servizio è immutabile, quindi è necessario creare un nuovo client per ogni servizio a cui si effettuano richieste o se si desidera utilizzare una configurazione diversa per effettuare richieste allo stesso servizio.
Non è necessario specificare `Region` nel service client builder per tutti i AWS servizi; tuttavia, è consigliabile impostare la regione per le chiamate API effettuate nelle applicazioni. Per ulteriori informazioni, consulta la sezione [Selezione della AWS regione](region-selection.md).
### Configurazione client predefinita
I generatori client dispongono di un altro metodo factory denominato `create()`. Questo metodo consente di creare un client del servizio con la configurazione predefinita. Utilizza la [catena di provider predefinita](credentials-chain.md) per caricare le credenziali e la [catena di Regione AWS provider predefinita](region-selection.md#automatically-determine-the-aws-region-from-the-environment). Se non è possibile determinare le credenziali o la regione dall'ambiente in cui è in esecuzione l'applicazione, la chiamata a `create` ha esito negativo. Vedi [Utilizzo delle credenziali](credentials.md) e [Selezione della regione](region-selection.md) per ulteriori informazioni su come l'SDK determina le credenziali e la regione da utilizzare.
Ad esempio, il seguente frammento di codice crea un'istanza di un `DynamoDbClient` oggetto come client di servizio per Amazon DynamoDB:
```
DynamoDbClient dynamoDbClient = DynamoDbClient.create();
```
### Configurare i client di servizio
Per informazioni dettagliate su come configurare i client di servizio, vedere [Configurazione del client esternamente](configuring-service-clients-ext.md) e[Configurazione del client in codice](configuring-service-clients-code.md).
### Chiudere il client di servizio
Come procedura ottimale, è consigliabile utilizzare un client di servizio per più chiamate al servizio API durante la vita di un'applicazione. Tuttavia, se hai bisogno di un client di servizio per un uso singolo o non hai più bisogno del client di servizio, chiudilo.
Richiamate il `close()` metodo quando il client di servizio non è più necessario per liberare risorse.
```
ec2Client.close();
```
Se hai bisogno di un client di servizio da utilizzare una sola volta, puoi creare un'istanza del client di servizio come risorsa in un'`try`istruzione -with-resources. I client di servizio implementano l'`[Autoclosable](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/AutoCloseable.html)`interfaccia, quindi il JDK chiama automaticamente il metodo alla fine dell'`close()`istruzione.
L'esempio seguente mostra come utilizzare un client di servizio per una chiamata una tantum. La chiamata `StsClient` che chiama AWS Security Token Service viene chiusa dopo la restituzione dell'ID dell'account.
```
import software.amazon.awssdk.services.sts.StsClient;
String getAccountID() {
try (StsClient stsClient = StsClient.create()) {
return stsClient.getCallerIdentity().account();
}
}
```
## Effettua richieste
Utilizza il client di servizio per effettuare richieste al corrispondente Servizio AWS.
Ad esempio, questo frammento di codice mostra come creare un `RunInstancesRequest` oggetto per creare una nuova istanza Amazon EC2:
```
// Create the request by using the fluid setter methods of the request builder.
RunInstancesRequest runInstancesRequest = RunInstancesRequest.builder()
.imageId(amiId)
.instanceType(InstanceType.T1_MICRO)
.maxCount(1)
.minCount(1)
.build();
// Use the configured request with the service client.
RunInstancesResponse response = ec2Client.runInstances(runInstancesRequest);
```
Anziché creare una richiesta e passarla all'istanza, l'SDK fornisce un'API fluida che puoi utilizzare per creare una richiesta. Con l'API fluent puoi utilizzare un'espressione lambda Java per creare la richiesta «in linea».
L'esempio seguente riscrive l'esempio precedente utilizzando la versione del `runInstances` [metodo che utilizza un](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/ec2/Ec2Client.html#runInstances(java.util.function.Consumer)) builder per creare la richiesta.
```
// Create the request by using a lambda expression.
RunInstancesResponse response = ec2.runInstances(r -> r
.imageId(amiId)
.instanceType(InstanceType.T1_MICRO)
.maxCount(1)
.minCount(1));
```
### Utilizzate le richieste per sovrascrivere la configurazione del client
Sebbene un client di servizio sia immutabile, è possibile sovrascrivere molte delle sue impostazioni a livello di richiesta. Quando si crea una richiesta, è possibile fornire un'[AwsRequestOverrideConfiguration](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/awscore/AwsRequestOverrideConfiguration.html)istanza per fornire le impostazioni sostituite. Alcuni dei metodi che puoi usare per sovrascrivere le impostazioni del client sono:
+ `apiCallAttemptTimeout`
+ `apiCallTimeout`
+ `credentialProvider`
+ `compressionConfiguration`
+ `putHeader`
Per un esempio di sovrascrittura di un'impostazione del client con una richiesta, supponiamo di avere il seguente client S3 che utilizza le impostazioni predefinite.
```
S3Client s3Client = S3Client.create();
```
Vuoi scaricare un file di grandi dimensioni e assicurarti che la richiesta non scada prima del termine del download. A tale scopo, aumenta i valori di timeout per una sola `GetObject` richiesta, come mostrato nel codice seguente.
------
#### [ Standard API ]
```
AwsRequestOverrideConfiguration overrideConfiguration = AwsRequestOverrideConfiguration.builder()
.apiCallTimeout(Duration.ofSeconds(100L))
.apiCallAttemptTimeout(Duration.ofSeconds(25L))
.build();
GetObjectRequest request = GetObjectRequest.builder()
.bucket("amzn-s3-demo-bucket")
.key("demo-key")
.overrideConfiguration(overrideConfiguration)
.build();
s3Client.getObject(request, myPath);
```
------
#### [ Fluent API ]
```
s3Client.getObject(b -> b
.bucket("amzn-s3-demo-bucket")
.key("demo-key")
.overrideConfiguration(c -> c
.apiCallTimeout(Duration.ofSeconds(100L))
.apiCallAttemptTimeout(Duration.ofSeconds(25L))),
myPath);
```
------
## Gestione delle risposte
L'SDK restituisce un oggetto di risposta per la maggior parte delle operazioni di servizio. Il codice può elaborare le informazioni nell'oggetto di risposta in base alle vostre esigenze.
Ad esempio, il seguente frammento di codice stampa l'ID di prima istanza restituito con l'[https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/ec2/model/RunInstancesResponse.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/ec2/model/RunInstancesResponse.html)oggetto dalla richiesta precedente.
```
RunInstancesResponse runInstancesResponse = ec2Client.runInstances(runInstancesRequest);
System.out.println(runInstancesResponse.instances().get(0).instanceId());
```
Tuttavia, non tutte le operazioni restituiscono un oggetto di risposta con dati specifici del servizio. In queste situazioni, è possibile interrogare lo stato della risposta HTTP per sapere se l'operazione ha avuto esito positivo.
Ad esempio, il codice nello snippet seguente verifica la risposta HTTP per verificare se il [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sesv2/SesV2Client.html#deleteContactList(software.amazon.awssdk.services.sesv2.model.DeleteContactListRequest)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sesv2/SesV2Client.html#deleteContactList(software.amazon.awssdk.services.sesv2.model.DeleteContactListRequest))funzionamento di Amazon Simple Email Service ha avuto successo.
```
SesV2Client sesv2Client = SesV2Client.create();
DeleteContactListRequest request = DeleteContactListRequest.builder()
.contactListName("ExampleContactListName")
.build();
DeleteContactListResponse response = sesv2Client.deleteContactList(request);
if (response.sdkHttpResponse().isSuccessful()) {
System.out.println("Contact list deleted successfully");
} else {
System.out.println("Failed to delete contact list. Status code: " + response.sdkHttpResponse().statusCode());
}
```
# Programmazione asincrona utilizzando il AWS SDK for Java 2.x
AWS SDK for Java 2.x Presenta client asincroni con I/O supporto non bloccante che implementano un'elevata concorrenza su pochi thread. Tuttavia, il totale non blocco non è garantito. I/O Il client asincrono può eseguire il blocco delle chiamate in alcuni casi, ad esempio nel recupero delle credenziali, nella firma delle richieste tramite [AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html) o nel rilevamento degli endpoint.
I metodi sincroni bloccano l'esecuzione del thread finché il client non riceve una risposta dal servizio. I metodi asincroni terminano immediatamente, riassegnando il controllo al thread chiamante senza attendere una risposta.
Poiché un metodo asincrono termina prima che sia disponibile una risposta, occorre un modo per ottenere la risposta quando è pronta. *I metodi per il client asincrono nella versione 2.x degli oggetti AWS SDK per Java CompletableFuture restituiti che consentono di accedere alla risposta quando è pronta.*
## Usa un client asincrono APIs
*Le firme dei metodi client asincroni sono le stesse della loro controparte sincrona, ma i metodi asincroni restituiscono un [CompletableFuture](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/CompletableFuture.html)oggetto che contiene i risultati dell'operazione asincrona futura.* Se viene generato un errore durante l'esecuzione del metodo asincrono dell'SDK, l'errore viene generato come. `CompletionException`
Un approccio che puoi utilizzare per ottenere il risultato consiste nel concatenare un `whenComplete()` metodo alla chiamata al metodo SDK restituita`CompletableFuture`. Il `whenComplete()` metodo riceve il risultato o un oggetto Throwable di tipo `CompletionException` a seconda del completamento della chiamata asincrona. Si esegue un'azione per elaborare o controllare `whenComplete()` i risultati prima che vengano restituiti al codice chiamante.
Se vuoi restituire qualcosa di diverso dall'oggetto restituito dal metodo SDK, usa invece il `handle()` metodo. Il `handle()` metodo accetta gli stessi parametri`whenComplete()`, ma potete elaborare il risultato e restituire un oggetto.
Per attendere il completamento della catena asincrona e recuperare i risultati del completamento, potete chiamare il metodo. `join()` Se l'`Throwable`oggetto non è stato gestito nella catena, il `join()` metodo genera un valore `CompletionException` deselezionato che racchiude l'eccezione originale. Si accede all'eccezione originale con. `CompletionException#getCause()` Puoi anche chiamare il `CompletableFuture#get()` metodo per ottenere i risultati del completamento. Il `get()` metodo, tuttavia, può generare eccezioni verificate.
L'esempio seguente mostra due varianti di come lavorare con il `listTables()` metodo del client asincrono DynamoDB. L'azione passata a registra `whenComplete()` semplicemente una risposta riuscita, mentre la `handle()` versione estrae l'elenco dei nomi delle tabelle e restituisce l'elenco. In entrambi i casi, se viene generato un errore nella catena asincrona, l'errore viene generato nuovamente in modo che il codice client abbia la possibilità di gestirlo.
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;
import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;
import java.util.List;
import java.util.concurrent.CompletableFuture;
```
**Codice**
------
#### [ whenComplete() variation ]
```
public class DynamoDbAsyncListTables {
public static void main(String[] args) {
Region region = Region.US_EAST_1;
DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbAsyncClient.builder().region(region).build();
try {
ListTablesResponse listTablesResponse = listTablesWhenComplete(dynamoDbAsyncClient).join(); // The join() method may throw a CompletionException.
if (listTablesResponse.hasTableNames()){
System.out.println("Table exist in this region: " + region.id());
}
} catch (RuntimeException e) {
// Handle as needed. Here we simply print out the class names.
System.out.println(e.getClass()); // Prints 'class java.util.concurrent.CompletionException'.
System.out.println(e.getCause().getClass()); // Prints 'class software.amazon.awssdk.services.dynamodb.model.DynamoDbException'.
}
}
public static CompletableFuture listTablesWhenComplete(DynamoDbAsyncClient client) {
return client.listTables(ListTablesRequest.builder().build())
.whenComplete((listTablesResponse, throwable) -> {
if (listTablesResponse != null) { // Consume the response.
System.out.println("The SDK's listTables method completed successfully.");
} else {
RuntimeException cause = (RuntimeException) throwable.getCause(); // If an error was thrown during the SDK's listTables method it is wrapped in a CompletionException.
// The SDK throws only RuntimeExceptions, so this is a safe cast.
System.out.println(cause.getMessage()); // Log error here, but rethrow so the calling code can handle as needed.
throw cause;
}
});
}
```
------
#### [ handle() variation ]
```
public class DynamoDbAsyncListTables {
public static void main(String[] args) {
Region region = Region.US_EAST_1;
DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbAsyncClient.builder().region(region).build();
try {
List tableNames = listTablesHandle(dynamoDbAsyncClient).join(); // The join() method may throw a CompletionException.
tableNames.forEach(System.out::println);
} catch (RuntimeException e) {
// Handle as needed. Here we simply print out the class names.
System.out.println(e.getClass()); // Prints 'class java.util.concurrent.CompletionException'.
System.out.println(e.getCause().getClass()); // Prints 'class software.amazon.awssdk.services.dynamodb.model.DynamoDbException'.
}
}
public static CompletableFuture> listTablesHandle(DynamoDbAsyncClient client) {
return client.listTables(ListTablesRequest.builder().build())
.handle((listTablesResponse, throwable) -> {
if (listTablesResponse != null) {
return listTablesResponse.tableNames(); // Return the list of table names.
} else {
RuntimeException cause = (RuntimeException) throwable.getCause(); // If an error was thrown during the SDK's listTables method it is wrapped in a CompletionException.
// The SDK throws only RuntimeExceptions, so this is a safe cast.
System.out.println(cause.getMessage()); // Log error here, but rethrow so the calling code can handle as needed.
throw cause;
}
});
}
}
```
------
## Gestisci lo streaming con metodi asincroni
Per i metodi asincroni con contenuti in streaming, è necessario fornire il contenuto in modo incrementale oppure un codice [AsyncRequestBody](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/AsyncRequestBody.html)per ricevere ed elaborare la risposta [AsyncResponseTransformer](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/AsyncResponseTransformer.html).
L'esempio seguente carica un file in modalità asincrona utilizzando la forma Amazon S3 asincrona dell'operazione. `PutObject`
**Importazioni**
```
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;
import java.nio.file.Paths;
import java.util.concurrent.CompletableFuture;
```
**Codice**
```
/**
* To run this AWS code example, ensure that you have setup your development environment, including your AWS credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class S3AsyncOps {
public static void main(String[] args) {
final String USAGE = "\n" +
"Usage:\n" +
" S3AsyncOps \n\n" +
"Where:\n" +
" bucketName - the name of the Amazon S3 bucket (for example, bucket1). \n\n" +
" key - the name of the object (for example, book.pdf). \n" +
" path - the local path to the file (for example, C:/AWS/book.pdf). \n" ;
if (args.length != 3) {
System.out.println(USAGE);
System.exit(1);
}
String bucketName = args[0];
String key = args[1];
String path = args[2];
Region region = Region.US_WEST_2;
S3AsyncClient client = S3AsyncClient.builder()
.region(region)
.build();
PutObjectRequest objectRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(key)
.build();
// Put the object into the bucket
CompletableFuture future = client.putObject(objectRequest,
AsyncRequestBody.fromFile(Paths.get(path))
);
future.whenComplete((resp, err) -> {
try {
if (resp != null) {
System.out.println("Object uploaded. Details: " + resp);
} else {
// Handle error
err.printStackTrace();
}
} finally {
// Only close the client when you are completely done with it
client.close();
}
});
future.join();
}
}
```
L'esempio seguente ottiene un file Amazon S3 da utilizzando la forma asincrona dell'operazione. `GetObject`
**Importazioni**
```
import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import java.nio.file.Paths;
import java.util.concurrent.CompletableFuture;
```
**Codice**
```
/**
* To run this AWS code example, ensure that you have setup your development environment, including your AWS credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class S3AsyncStreamOps {
public static void main(String[] args) {
final String USAGE = "\n" +
"Usage:\n" +
" S3AsyncStreamOps \n\n" +
"Where:\n" +
" bucketName - the name of the Amazon S3 bucket (for example, bucket1). \n\n" +
" objectKey - the name of the object (for example, book.pdf). \n" +
" path - the local path to the file (for example, C:/AWS/book.pdf). \n" ;
if (args.length != 3) {
System.out.println(USAGE);
System.exit(1);
}
String bucketName = args[0];
String objectKey = args[1];
String path = args[2];
Region region = Region.US_WEST_2;
S3AsyncClient client = S3AsyncClient.builder()
.region(region)
.build();
GetObjectRequest objectRequest = GetObjectRequest.builder()
.bucket(bucketName)
.key(objectKey)
.build();
CompletableFuture futureGet = client.getObject(objectRequest,
AsyncResponseTransformer.toFile(Paths.get(path)));
futureGet.whenComplete((resp, err) -> {
try {
if (resp != null) {
System.out.println("Object downloaded. Details: "+resp);
} else {
err.printStackTrace();
}
} finally {
// Only close the client when you are completely done with it
client.close();
}
});
futureGet.join();
}
}
```
## Configura opzioni asincrone avanzate
La AWS SDK per Java 2.x utilizza [Netty](https://netty.io), un framework applicativo di rete asincrono basato sugli eventi, per gestire i thread. I/O Il AWS SDK per Java 2.x crea un `ExecutorService` behind Netty, per completare i futures restituiti dalla richiesta del client HTTP al client Netty. Questa astrazione riduce il rischio che un'applicazione interrompa il processo asincrono se gli sviluppatori scelgono di arrestare o sospendere i thread. Per impostazione predefinita, ogni client asincrono crea un pool di thread in base al numero di processori e gestisce le attività in una coda all'interno di. `ExecutorService`
È possibile specificare un'implementazione JDK specifica quando si crea il client asincrono. `ExecutorService` Il seguente frammento crea un file con un `ExecutorService` numero fisso di thread.
**Codice**
```
S3AsyncClient clientThread = S3AsyncClient.builder()
.asyncConfiguration(
b -> b.advancedOption(SdkAdvancedAsyncClientOption
.FUTURE_COMPLETION_EXECUTOR,
Executors.newFixedThreadPool(10)
)
)
.build();
```
Per ottimizzare le prestazioni, puoi gestire il tuo esecutore del pool di thread e includerlo nella configurazione del client.
```
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 50,
10, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
new ThreadFactoryBuilder()
.threadNamePrefix("sdk-async-response").build());
// Allow idle core threads to time out
executor.allowCoreThreadTimeOut(true);
S3AsyncClient clientThread = S3AsyncClient.builder()
.asyncConfiguration(
b -> b.advancedOption(SdkAdvancedAsyncClientOption
.FUTURE_COMPLETION_EXECUTOR,
executor
)
)
.build();
```
# Le migliori pratiche per l'utilizzo di AWS SDK for Java 2.x
## Impedisci il blocco delle richieste configurando i timeout delle API
L'SDK fornisce [valori predefiniti](https://github.com/aws/aws-sdk-java-v2/blob/a0c8a0af1fa572b16b5bd78f310594d642324156/http-client-spi/src/main/java/software/amazon/awssdk/http/SdkHttpConfigurationOption.java#L134) per alcune opzioni di timeout, come il timeout di connessione e i timeout dei socket, ma non per i timeout delle chiamate API o i timeout dei singoli tentativi di chiamata API. È buona norma impostare i timeout sia per i singoli tentativi che per l'intera richiesta. Ciò garantirà un guasto rapido dell'applicazione in modo ottimale in caso di problemi temporanei che potrebbero causare tempi più lunghi per il completamento dei tentativi di richiesta o problemi di rete irreversibili.
È possibile configurare i timeout per tutte le richieste effettuate dai client di un servizio utilizzando and. `[ClientOverrideConfiguration\$1apiCallAttemptTimeout](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/client/config/ClientOverrideConfiguration.html#apiCallAttemptTimeout())` `[ClientOverrideConfiguration\$1apiCallTimeout](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/client/config/ClientOverrideConfiguration.html#apiCallTimeout())`
L'esempio seguente mostra la configurazione di un client Amazon S3 con valori di timeout personalizzati.
```
S3Client.builder()
.overrideConfiguration(
b -> b.apiCallTimeout(Duration.ofSeconds())
.apiCallAttemptTimeout(Duration.ofMillis()))
.build();
```
**`apiCallAttemptTimeout`**
Questa impostazione imposta la quantità di tempo per un singolo tentativo HTTP, dopodiché la chiamata API può essere ritentata.
**`apiCallTimeout`**
Il valore di questa proprietà configura la quantità di tempo per l'intera esecuzione, inclusi tutti i tentativi di nuovo tentativo.
In alternativa all'impostazione di questi valori di timeout sul client del servizio, è possibile utilizzare [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/RequestOverrideConfiguration.html#apiCallTimeout()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/RequestOverrideConfiguration.html#apiCallTimeout())e `[RequestOverrideConfiguration\$1apiCallAttemptTimeout()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/RequestOverrideConfiguration.html#apiCallAttemptTimeout())` configurare una singola richiesta.
L'esempio seguente configura una singola `listBuckets` richiesta con valori di timeout personalizzati.
```
s3Client.listBuckets(lbr -> lbr.overrideConfiguration(
b -> b.apiCallTimeout(Duration.ofSeconds())
.apiCallAttemptTimeout(Duration.ofMillis())));
```
Quando si utilizzano queste proprietà insieme, si imposta un limite rigido al tempo totale impiegato per tutti i tentativi tra più tentativi. È inoltre possibile impostare una richiesta HTTP individuale in modo che abbia esito negativo rapidamente in caso di richiesta lenta.
## Migliora le prestazioni riutilizzando i client di servizio
Ogni [client di servizio](work-witih-clients.md) mantiene il proprio pool di connessioni HTTP. Una connessione già esistente nel pool può essere riutilizzata con una nuova richiesta per ridurre il tempo necessario per stabilire una nuova connessione. Ti consigliamo di condividere una singola istanza del client per evitare il sovraccarico dovuto alla presenza di troppi pool di connessioni che non vengono utilizzati in modo efficace. Tutti i client di servizio sono thread-safe.
Se non vuoi condividere un'istanza client, chiama `close()` l'istanza per rilasciare le risorse quando il client non è necessario.
## Previeni le fughe di risorse chiudendo i client di servizio inutilizzati
Chiudi un [client di servizio](work-witih-clients.md) per rilasciare risorse, come i thread, se non sono più necessarie. Se non desideri condividere un'istanza client, richiedi `close()` all'istanza di rilasciare le risorse quando il client non è necessario.
## Previeni l'esaurimento del pool di connessioni chiudendo i flussi di input
Per operazioni di streaming`[S3Client\$1getObject](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#getObject(java.util.function.Consumer,java.nio.file.Path))`, ad esempio se lavori `[ResponseInputStream](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/ResponseInputStream.html)` direttamente con, ti consigliamo di fare quanto segue:
+ Leggi tutti i dati del flusso di input il prima possibile.
+ Chiudi il flusso di input il prima possibile.
Forniamo questi consigli perché il flusso di input è un flusso diretto di dati proveniente dalla connessione HTTP e la connessione HTTP sottostante non può essere riutilizzata finché tutti i dati dello stream non sono stati letti e lo stream non viene chiuso. Se queste regole non vengono seguite, il client può esaurire le risorse allocando troppe connessioni HTTP aperte ma inutilizzate.
## Ottimizza le prestazioni HTTP per il carico di lavoro delle tue applicazioni
L'SDK fornisce una serie di [configurazioni http predefinite](https://github.com/aws/aws-sdk-java-v2/blob/master/http-client-spi/src/main/java/software/amazon/awssdk/http/SdkHttpConfigurationOption.java) che si applicano ai casi d'uso generali. Consigliamo ai clienti di ottimizzare le configurazioni HTTP per le loro applicazioni in base ai loro casi d'uso.
Come buon punto di partenza, l'SDK offre una funzionalità di [configurazione predefinita intelligente](http-configuration.md#http-config-smart-defaults). Questa funzionalità è disponibile a partire dalla versione 2.17.102. È possibile scegliere una modalità in base al caso d'uso, che fornisce valori di configurazione ragionevoli.
## Migliora le prestazioni SSL con OpenSSL per client asincroni
Per impostazione predefinita, l'SDK [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/http/nio/netty/NettyNioAsyncHttpClient.html)utilizza l'implementazione SSL predefinita di JDK come. `SslProvider` I nostri test hanno rilevato che OpenSSL offre prestazioni migliori rispetto all'implementazione predefinita di JDK. La community di Netty [consiglia inoltre di utilizzare OpenSSL](https://netty.io/wiki/requirements-for-4.x.html#tls-with-openssl).
Per usare OpenSSL, `netty-tcnative` aggiungilo alle tue dipendenze. Per i dettagli di configurazione, consulta la documentazione del progetto [Netty](https://netty.io/wiki/forked-tomcat-native.html).
Dopo aver `netty-tcnative` configurato il progetto, l'`NettyNioAsyncHttpClient`istanza selezionerà automaticamente OpenSSL. In alternativa, puoi impostarlo in `SslProvider` modo esplicito utilizzando il `NettyNioAsyncHttpClient` builder, come mostrato nel seguente frammento.
```
NettyNioAsyncHttpClient.builder()
.sslProvider(SslProvider.OPENSSL)
.build();
```
## Monitora le prestazioni delle applicazioni con le metriche SDK
L'SDK for Java [può raccogliere](metrics.md) metriche per i client di servizio dell'applicazione. Puoi utilizzare queste metriche per identificare problemi di prestazioni, esaminare le tendenze complessive di utilizzo, esaminare le eccezioni restituite dai client di servizio o per approfondire un problema particolare.
Ti consigliamo di raccogliere parametri, quindi analizzare Amazon CloudWatch Logs, per ottenere una comprensione più approfondita delle prestazioni della tua applicazione.
# Gestione degli errori nel AWS SDK for Java 2.x
Comprendere come e quando vengono AWS SDK for Java 2.x generate le eccezioni è importante per creare applicazioni di alta qualità utilizzando l'SDK. Nelle seguenti sezioni vengono descritti i diversi casi di eccezioni che vengono generate dall'SDK e come gestirle in modo appropriato.
## Perché le eccezioni non sono controllate?
AWS SDK per Java Utilizza eccezioni di runtime (o non controllate) anziché eccezioni controllate per questi motivi:
+ Per consentire agli sviluppatori di controllare ogni dettaglio degli errori che desiderano gestire senza costringerli a gestire casi eccezionali che non destino preoccupazione (rendendo il codice eccessivamente dettagliato)
+ Per prevenire problemi di scalabilità intrinseca con eccezioni controllate in applicazioni di grandi dimensioni
In generale, le eccezioni controllate funzionano bene su scale ridotte, ma possono diventare problematiche all'aumentare delle dimensioni e della complessità delle applicazioni.
## AwsServiceException (e sottoclassi)
[AwsServiceException](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/awscore/exception/AwsServiceException.html)è l'eccezione più comune che si verificherà quando si utilizza. AWS SDK per Java`AwsServiceException`è una sottoclasse di quella più generale [SdkServiceException](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/exception/SdkServiceException.html). `AwsServiceException`s rappresenta una risposta di errore da un Servizio AWS. Ad esempio, se provi a terminare un' Amazon EC2 istanza che non esiste, Amazon EC2 restituirà una risposta di errore e tutti i dettagli di tale risposta di errore verranno inclusi nella `AwsServiceException` risposta generata.
Quando incontri un`AwsServiceException`, sai che la tua richiesta è stata inviata con successo a Servizio AWS ma non può essere elaborata correttamente. Questo può essere dovuto a errori nei parametri della richiesta o a errori sul lato servizio.
`AwsServiceException` fornisce informazioni quali:
+ Codice di stato HTTP restituito
+ Codice AWS di errore restituito
+ Messaggio di errore dettagliato del servizio della [AwsErrorDetails](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/awscore/exception/AwsErrorDetails.html)classe
+ AWS ID della richiesta non riuscita
Nella maggior parte dei casi, `AwsServiceException` viene generata una sottoclasse specifica del servizio di per consentire agli sviluppatori un controllo granulare sulla gestione dei casi di errore tramite i block catch. Il riferimento all'API Java SDK per visualizzare il gran numero di sottoclassi. [AwsServiceException](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/awscore/exception/AwsServiceException.html)`AwsServiceException` Utilizza i collegamenti alle sottoclassi per visualizzare in dettaglio le eccezioni granulari generate da un servizio.
Ad esempio, i seguenti collegamenti al riferimento dell'API SDK mostrano le gerarchie delle eccezioni per alcune comuni. Servizi AWS L'elenco delle sottoclassi mostrato in ogni pagina mostra le eccezioni specifiche che il codice può catturare.
+ [Amazon S3](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/model/S3Exception.html)
+ [DynamoDB](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/model/DynamoDbException.html)
+ [Amazon SQS](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SqsException.html)
Per ulteriori informazioni su un'eccezione, ispeziona l'`errorCode`oggetto. [AwsErrorDetails](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/awscore/exception/AwsErrorDetails.html) È possibile utilizzare il `errorCode` valore per cercare informazioni nell'API della guida ai servizi. Ad esempio, se `S3Exception` viene rilevato un e il `AwsErrorDetails#errorCode()` valore è`InvalidRequest`, utilizza l'[elenco dei codici di errore](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList) nell'Amazon S3 API Reference per visualizzare ulteriori dettagli.
## SdkClientException
[SdkClientException](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/exception/SdkClientException.html)indica che si è verificato un problema all'interno del codice client Java, durante il tentativo di inviare una richiesta a AWS o durante il tentativo di analizzare una risposta da. AWS Un `SdkClientException` è generalmente più grave di un `SdkServiceException` e indica un problema importante che impedisce al client di effettuare chiamate di servizio ai AWS servizi. Ad esempio, AWS SDK per Java genera una connessione di rete `SdkClientException` se non è disponibile alcuna connessione di rete quando si tenta di richiamare un'operazione su uno dei client.
## Eccezioni e comportamento nei tentativi
L'SDK for Java ritenta le richieste per [diverse eccezioni lato client](https://github.com/aws/aws-sdk-java-v2/blob/13985e0668a9a0b12ad331644e3c4fd1385c2cd7/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/retry/SdkDefaultRetrySetting.java#L79C41-L79C41) e [per i codici di stato HTTP](https://github.com/aws/aws-sdk-java-v2/blob/13985e0668a9a0b12ad331644e3c4fd1385c2cd7/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/retry/SdkDefaultRetrySetting.java#L72C31-L72C31) che riceve dalle risposte. Servizio AWS Questi errori vengono gestiti come parte dell'eredità utilizzata dai client di servizio per impostazione predefinita`RetryMode`. Il riferimento all'API Java per `[RetryMode](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/RetryMode.html)` descrive i vari modi in cui è possibile configurare la modalità.
Per personalizzare le eccezioni e i codici di stato HTTP che attivano i nuovi tentativi automatici, configura il client di servizio con un programma `[RetryPolicy](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/RetryPolicy.html)` che aggiunge `[RetryOnExceptionsCondition](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/retry/conditions/RetryOnExceptionsCondition.html)` istanze`[RetryOnStatusCodeCondition](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/awscore/retry/conditions/RetryOnErrorCodeCondition.html)`.
# Utilizzo dei risultati impaginati nella versione 2.x AWS SDK per Java
Molte AWS operazioni restituiscono risultati impaginati quando l'oggetto di risposta è troppo grande per essere restituito in un'unica risposta. Nella AWS SDK per Java versione 1.0, la risposta contiene un token da utilizzare per recuperare la pagina successiva dei risultati. Al contrario, la versione AWS SDK per Java 2.x dispone di metodi di autopaginazione che effettuano più chiamate di servizio per visualizzare automaticamente la pagina successiva dei risultati. Occorre solo scrivere il codice che elabora i risultati. L'autopaginazione è disponibile sia per i client sincroni che asincroni.
**Nota**
[Questi frammenti di codice presuppongono che tu conosca le [basi dell'utilizzo dell'SDK e che tu abbia configurato il tuo ambiente con l'accesso Single Sign-On](using.md).](get-started-auth.md#setup-credentials)
## Impaginazione sincrona
Gli esempi seguenti mostrano i metodi di impaginazione sincroni per elencare gli oggetti in un bucket. Amazon S3
### Iterate sulle pagine
Il primo esempio dimostra l'uso di un oggetto `listRes` paginator, un'[https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/paginators/ListObjectsV2Iterable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/paginators/ListObjectsV2Iterable.html)istanza, per scorrere tutte le pagine di risposta con il metodo. `stream` Il codice scorre sulle pagine di risposta, converte il flusso di risposta in un flusso di `[S3Object](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/model/S3Object.html)` contenuti e quindi elabora il contenuto dell'oggetto. Amazon S3
Le seguenti importazioni si applicano a tutti gli esempi di questa sezione di impaginazione sincrona.
#### Importazioni
```
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Random;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.S3Object;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;
import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;
import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;
import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
import software.amazon.awssdk.services.s3.model.CompletedPart;
import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;
import software.amazon.awssdk.services.s3.model.UploadPartRequest;
import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;
import software.amazon.awssdk.services.s3.waiters.S3Waiter;
import software.amazon.awssdk.services.s3.model.HeadBucketRequest;
import software.amazon.awssdk.services.s3.model.HeadBucketResponse;
```
```
ListObjectsV2Request listReq = ListObjectsV2Request.builder()
.bucket(bucketName)
.maxKeys(1)
.build();
ListObjectsV2Iterable listRes = s3.listObjectsV2Paginator(listReq);
// Process response pages
listRes.stream()
.flatMap(r -> r.contents().stream())
.forEach(content -> System.out
.println(" Key: " + content.key() + " size = " + content.size()));
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L112) su. GitHub
### Iterate sugli oggetti
Negli esempi seguenti vengono mostrati dei metodi per effettuare l'iterazione sugli oggetti restituiti nella risposta invece che delle pagine della risposta. Il `contents` metodo di `ListObjectsV2Iterable` classe restituisce un [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/pagination/sync/SdkIterable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/pagination/sync/SdkIterable.html)che fornisce diversi metodi per elaborare gli elementi di contenuto sottostanti.
#### Usa uno stream
Il seguente frammento utilizza il `stream` metodo sul contenuto della risposta per iterare sulla raccolta di elementi impaginati.
```
// Helper method to work with paginated collection of items directly.
listRes.contents().stream()
.forEach(content -> System.out
.println(" Key: " + content.key() + " size = " + content.size()));
```
[Vedi l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L127) GitHub
#### Usa un ciclo for-each
Poiché `SdkIterable` estende l'`Iterable`interfaccia, puoi elaborare i contenuti come qualsiasi altro. `Iterable` Il seguente frammento utilizza un `for-each` ciclo standard per scorrere il contenuto della risposta.
```
for (S3Object content : listRes.contents()) {
System.out.println(" Key: " + content.key() + " size = " + content.size());
}
```
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L133) su. GitHub
### Impaginazione manuale
Se il caso d'uso lo richiede, la paginazione manuale è ancora disponibile. Utilizza il token successivo dell'oggetto di risposta per le richieste successive. L'esempio seguente utilizza un `while` ciclo.
```
ListObjectsV2Request listObjectsReqManual = ListObjectsV2Request.builder()
.bucket(bucketName)
.maxKeys(1)
.build();
boolean done = false;
while (!done) {
ListObjectsV2Response listObjResponse = s3.listObjectsV2(listObjectsReqManual);
for (S3Object content : listObjResponse.contents()) {
System.out.println(content.key());
}
if (listObjResponse.nextContinuationToken() == null) {
done = true;
}
listObjectsReqManual = listObjectsReqManual.toBuilder()
.continuationToken(listObjResponse.nextContinuationToken())
.build();
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/s3/src/main/java/com/example/s3/S3ObjectOperations.java#L90) su GitHub.
## Impaginazione asincrona
Gli esempi seguenti mostrano i metodi di impaginazione asincrona per elencare le tabelle. DynamoDB
### Iterate su pagine di nomi di tabelle
I due esempi seguenti utilizzano un client DynamoDB asincrono che chiama `listTablesPaginator` il metodo con una richiesta per ottenere un. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/paginators/ListTablesPublisher.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/dynamodb/paginators/ListTablesPublisher.html) `ListTablesPublisher`implementa due interfacce, che forniscono molte opzioni per elaborare le risposte. Esamineremo i metodi di ciascuna interfaccia.
#### Usa un `Subscriber`
Il seguente esempio di codice dimostra come elaborare i risultati impaginati utilizzando l'`org.reactivestreams.Publisher`interfaccia implementata da. `ListTablesPublisher` [Per ulteriori informazioni sul modello Reactive Streams, consulta il repository Reactive Streams. GitHub ](https://github.com/reactive-streams/reactive-streams-jvm/blob/v1.0.2/README.md)
Le seguenti importazioni si applicano a tutti gli esempi di questa sezione di impaginazione asincrona.
##### Importazioni
```
import io.reactivex.rxjava3.core.Flowable;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import reactor.core.publisher.Flux;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;
import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;
import software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
```
Il codice seguente acquisisce un'istanza. `ListTablesPublisher`
```
// Creates a default client with credentials and region loaded from the
// environment.
final DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();
ListTablesRequest listTablesRequest = ListTablesRequest.builder().limit(3).build();
ListTablesPublisher publisher = asyncClient.listTablesPaginator(listTablesRequest);
```
Il codice seguente utilizza un'implementazione anonima di `org.reactivestreams.Subscriber` per elaborare i risultati di ogni pagina.
Il metodo `onSubscribe` chiama il metodo `Subscription.request` per avviare le richieste per i dati del publisher. Questo metodo deve essere chiamato per iniziare a ottenere i dati dal publisher.
Il `onNext` metodo del sottoscrittore elabora una pagina di risposta accedendo a tutti i nomi delle tabelle e stampandoli ciascuno. Dopo l'elaborazione della pagina, viene richiesta un'altra pagina all'editore. Questo metodo viene chiamato ripetutamente fino al recupero di tutte le pagine.
Il metodo `onError` viene attivato se si verifica un errore durante il recupero dei dati. Infine, il metodo `onComplete` viene chiamato quando tutte le pagine sono state richieste.
```
// A Subscription represents a one-to-one life-cycle of a Subscriber subscribing
// to a Publisher.
publisher.subscribe(new Subscriber() {
// Maintain a reference to the subscription object, which is required to request
// data from the publisher.
private Subscription subscription;
@Override
public void onSubscribe(Subscription s) {
subscription = s;
// Request method should be called to demand data. Here we request a single
// page.
subscription.request(1);
}
@Override
public void onNext(ListTablesResponse response) {
response.tableNames().forEach(System.out::println);
// After you process the current page, call the request method to signal that
// you are ready for next page.
subscription.request(1);
}
@Override
public void onError(Throwable t) {
// Called when an error has occurred while processing the requests.
}
@Override
public void onComplete() {
// This indicates all the results are delivered and there are no more pages
// left.
}
});
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L83) su. GitHub
#### Usa un `Consumer`
L'`SdkPublisher`interfaccia che `ListTablesPublisher` implementa ha un `subscribe` metodo che accetta un `Consumer` e restituisce un`CompletableFuture`.
Il `subscribe` metodo di questa interfaccia può essere utilizzato per casi d'uso semplici in cui un `org.reactivestreams.Subscriber` potrebbe comportare un sovraccarico eccessivo. Poiché il codice seguente utilizza ogni pagina, chiama il `tableNames` metodo su ciascuna di esse. Il `tableNames` metodo restituisce uno `java.util.List` dei nomi di tabella DynamoDB elaborati con il metodo. `forEach`
```
// Use a Consumer for simple use cases.
CompletableFuture future = publisher.subscribe(
response -> response.tableNames()
.forEach(System.out::println));
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L96) su. GitHub
### Esegui iterazioni sui nomi delle tabelle
Negli esempi seguenti vengono mostrati dei metodi per effettuare l'iterazione sugli oggetti restituiti nella risposta invece che delle pagine della risposta. Analogamente all'esempio sincrono di Amazon S3 illustrato in precedenza con il `contents` relativo metodo, la classe `ListTablesPublisher` di risultati asincrona di DynamoDB ha il metodo pratico per interagire con `tableNames` la raccolta di elementi sottostante. Il tipo di restituzione del `tableNames` metodo è un metodo [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/SdkPublisher.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/async/SdkPublisher.html)che può essere utilizzato per richiedere elementi su tutte le pagine.
#### Usa un `Subscriber`
Il codice seguente acquisisce uno `SdkPublisher` dei nomi di tabella sottostanti.
```
// Create a default client with credentials and region loaded from the
// environment.
final DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();
ListTablesRequest listTablesRequest = ListTablesRequest.builder().limit(3).build();
ListTablesPublisher listTablesPublisher = asyncClient.listTablesPaginator(listTablesRequest);
SdkPublisher publisher = listTablesPublisher.tableNames();
```
Il codice seguente utilizza un'implementazione anonima di `org.reactivestreams.Subscriber` per elaborare i risultati di ogni pagina.
Il `onNext` metodo del sottoscrittore elabora un singolo elemento della raccolta. In questo caso, è un nome di tabella. Dopo l'elaborazione del nome della tabella, viene richiesto un altro nome di tabella all'editore. Questo metodo viene chiamato ripetutamente fino al recupero di tutti i nomi delle tabelle.
```
// Use a Subscriber.
publisher.subscribe(new Subscriber() {
private Subscription subscription;
@Override
public void onSubscribe(Subscription s) {
subscription = s;
subscription.request(1);
}
@Override
public void onNext(String tableName) {
System.out.println(tableName);
subscription.request(1);
}
@Override
public void onError(Throwable t) {
}
@Override
public void onComplete() {
}
});
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L147) su. GitHub
#### Usa un `Consumer`
L'esempio seguente utilizza il `subscribe` metodo `SdkPublisher` che richiede `Consumer` a per elaborare ogni elemento.
```
// Use a Consumer.
CompletableFuture future = publisher.subscribe(System.out::println);
future.get();
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L161) su GitHub.
### Usa una libreria di terze parti
Puoi utilizzare altre librerie di terze parti anziché implementare un sottoscrittore personalizzato. Questo esempio dimostra l'uso di RxJava, ma è possibile utilizzare qualsiasi libreria che implementa le interfacce di flusso reattivo. Vedi la [pagina RxJava wiki su GitHub per ulteriori informazioni su](https://github.com/ReactiveX/RxJava/wiki) quella libreria.
Per utilizzare la libreria, aggiungerla come una dipendenza. Se utilizzi Maven, l'esempio illustra lo snippet POM da utilizzare.
**Voce POM**
```
io.reactivex.rxjava3
rxjava
3.1.6
```
**Codice**
```
DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();
ListTablesPublisher publisher = asyncClient.listTablesPaginator(ListTablesRequest.builder()
.build());
// The Flowable class has many helper methods that work with
// an implementation of an org.reactivestreams.Publisher.
List tables = Flowable.fromPublisher(publisher)
.flatMapIterable(ListTablesResponse::tableNames)
.toList()
.blockingGet();
System.out.println(tables);
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/f807d60010caf3d14fe4cd0801b842fb8e9511ca/javav2/example_code/dynamodbasync/src/main/java/com/example/dynamodbasync/AsyncPagination.java#L198) su GitHub.
# Usare i camerieri nel AWS SDK for Java 2.x
L'utilità waiters della versione AWS SDK per Java 2.x consente di verificare che le risorse si trovino in uno stato specifico prima di eseguire operazioni su tali AWS risorse.
Un *cameriere* è un'astrazione utilizzata per esaminare le AWS risorse, come DynamoDB tabelle o Amazon S3 bucket, fino al raggiungimento dello stato desiderato (o fino a quando non viene stabilito che la risorsa non raggiungerà mai lo stato desiderato). Invece di scrivere una logica per il polling continuo AWS delle risorse, operazione che può essere complessa e soggetta a errori, è possibile utilizzare i camerieri per interrogare una risorsa e far sì che il codice continui a funzionare quando la risorsa è pronta.
## Prerequisiti
[Prima di poter utilizzare i camerieri in un progetto con, è necessario completare i passaggi descritti in Configurazione della versione AWS SDK per Java 2.x. AWS SDK per Java](setup.md)
È inoltre necessario configurare le dipendenze del progetto (ad esempio, nel `build.gradle` file `pom.xml` o) per utilizzare la versione `2.15.0` o successiva di. AWS SDK per Java
Esempio:
```
software.amazon.awssdk
bom
2.27.21
pom
import
```
## Usare i camerieri
Per creare un'istanza di un oggetto waiters, crea prima un client di servizio. Imposta il `waiter()` metodo del client del servizio come valore dell'oggetto waiter. Una volta che l'istanza del cameriere esiste, imposta le sue opzioni di risposta per eseguire il codice appropriato.
### Programmazione sincrona
**Il seguente frammento di codice mostra come attendere che una DynamoDB tabella esista e sia in uno stato ATTIVO.**
```
DynamoDbClient dynamo = DynamoDbClient.create();
DynamoDbWaiter waiter = dynamo.waiter();
WaiterResponse waiterResponse =
waiter.waitUntilTableExists(r -> r.tableName("myTable"));
// print out the matched response with a tableStatus of ACTIVE
waiterResponse.matched().response().ifPresent(System.out::println);
```
### Programmazione asincrona
Il seguente frammento di codice mostra come attendere che una DynamoDB tabella non esista più.
```
DynamoDbAsyncClient asyncDynamo = DynamoDbAsyncClient.create();
DynamoDbAsyncWaiter asyncWaiter = asyncDynamo.waiter();
CompletableFuture> waiterResponse =
asyncWaiter.waitUntilTableNotExists(r -> r.tableName("myTable"));
waiterResponse.whenComplete((r, t) -> {
if (t == null) {
// print out the matched ResourceNotFoundException
r.matched().exception().ifPresent(System.out::println);
}
}).join();
```
## Configura i camerieri
Puoi personalizzare la configurazione di un cameriere utilizzando il comando `overrideConfiguration()` on its builder. Per alcune operazioni, è possibile applicare una configurazione personalizzata quando si effettua la richiesta.
### Configura un cameriere
Il seguente frammento di codice mostra come sovrascrivere la configurazione su un cameriere.
```
// sync
DynamoDbWaiter waiter =
DynamoDbWaiter.builder()
.overrideConfiguration(b -> b.maxAttempts(10))
.client(dynamoDbClient)
.build();
// async
DynamoDbAsyncWaiter asyncWaiter =
DynamoDbAsyncWaiter.builder()
.client(dynamoDbAsyncClient)
.overrideConfiguration(o -> o.backoffStrategy(
FixedDelayBackoffStrategy.create(Duration.ofSeconds(2))))
.scheduledExecutorService(Executors.newScheduledThreadPool(3))
.build();
```
### Sostituisci la configurazione per una richiesta specifica
Il seguente frammento di codice mostra come sovrascrivere la configurazione di un cameriere in base alla richiesta. Nota che solo alcune operazioni hanno configurazioni personalizzabili.
```
waiter.waitUntilTableNotExists(b -> b.tableName("myTable"),
o -> o.maxAttempts(10));
asyncWaiter.waitUntilTableExists(b -> b.tableName("myTable"),
o -> o.waitTimeout(Duration.ofMinutes(1)));
```
## Esempi di codice
Per un esempio completo di utilizzo di waiters with DynamoDB, consulta [CreateTable.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/869b7ddbc7c8f66c7c45acd5b813429aff37003e/javav2/example_code/dynamodb/src/main/java/com/example/dynamodb/CreateTable.java) nel Code Examples Repository. AWS
Per un esempio completo di utilizzo di waiters with Amazon S3, vedete [S3 BucketOps](https://github.com/awsdocs/aws-doc-sdk-examples/blob/869b7ddbc7c8f66c7c45acd5b813429aff37003e/javav2/example_code/s3/src/main/java/com/example/s3/S3BucketOps.java) .java nel Code Examples Repository. AWS
# Risoluzione dei problemi FAQs
Quando si utilizza il AWS SDK for Java 2.x nelle applicazioni, è possibile che si verifichino gli errori di runtime elencati in questo argomento. Utilizzate i suggerimenti riportati di seguito per individuare la causa principale e risolvere l'errore.
## Come posso correggere l'errore "`java.net.SocketException`: ripristino della connessione» o «il server non è riuscito a completare la risposta»?
Un errore di reimpostazione della connessione indica che l'host Servizio AWS, l'intermediario (ad esempio un gateway NAT, un proxy, un sistema di bilanciamento del carico) ha chiuso la connessione prima del completamento della richiesta. Poiché le cause sono molteplici, per trovare una soluzione è necessario conoscere il motivo per cui la connessione viene chiusa. I seguenti elementi causano in genere la chiusura di una connessione.
+ **La connessione non è attiva.**Ciò è comune nelle operazioni di streaming, in cui i dati non vengono scritti sul cavo o dal cavo per un certo periodo di tempo, quindi una parte intermediaria rileva che la connessione è interrotta e la chiude. Per evitare che ciò accada, assicurati che l'applicazione scarichi o carichi attivamente i dati.
+ **Hai chiuso il client HTTP o SDK.** Assicurati di non chiudere le risorse mentre sono in uso.
+ **Un proxy configurato in modo errato.** Prova a bypassare tutti i proxy che hai configurato per vedere se il problema viene risolto. Se questo risolve il problema, il proxy sta chiudendo la connessione per qualche motivo. Cerca il tuo proxy specifico per determinare il motivo per cui sta chiudendo la connessione.
Se non riesci a identificare il problema, prova a eseguire un dump TCP per una connessione interessata sul lato client della rete (ad esempio, dopo tutti i proxy che controlli).
Se vedi che l' AWS endpoint sta inviando un `TCP RST` (ripristino), [contatta il servizio interessato](https://aws.amazon.com/contact-us/) per vedere se è in grado di determinare il motivo del ripristino. Preparati a fornire la richiesta IDs e l'ora in cui si è verificato il problema. Il team di AWS supporto potrebbe inoltre trarre vantaggio dai [registri telefonici](logging-slf4j.md#sdk-java-logging-verbose) che mostrano esattamente quali byte vengono inviati e ricevuti dall'applicazione e quando.
## Come posso correggere il «timeout della connessione»?
Un errore di timeout della connessione indica che l'host Servizio AWS, il server o qualsiasi intermediario (ad esempio un gateway NAT, un proxy, un sistema di bilanciamento del carico) non è riuscito a stabilire una nuova connessione con il server entro il timeout di connessione configurato. I seguenti elementi descrivono le cause più comuni di questo problema.
+ **Il timeout di connessione configurato è troppo basso.** Per impostazione predefinita, il timeout della connessione è di 2 secondi in. AWS SDK for Java 2.x Se il timeout di connessione è impostato su un valore troppo basso, è possibile che venga visualizzato questo errore. Il timeout di connessione consigliato è di 1 secondo se si effettuano solo chiamate interregionali e di 3 secondi se si effettuano richieste interregionali.
+ **Un proxy configurato in modo errato.** Prova a bypassare tutti i proxy che hai configurato per vedere se il problema viene risolto. Se questo risolve il problema, il motivo del timeout della connessione è il proxy. Cerca il tuo proxy specifico per determinare il motivo per cui ciò sta accadendo
Se non riesci a identificare il problema, prova a eseguire un dump TCP per una connessione interessata sul lato client della rete (ad esempio, dopo tutti i proxy che controlli) per esaminare eventuali problemi di rete.
## Come posso risolvere il problema "`java.net.SocketTimeoutException`: Read timeout»?
Un errore di timeout di lettura indica che la JVM ha tentato di leggere i dati dal sistema operativo sottostante, ma i dati non sono stati restituiti entro il tempo configurato tramite l'SDK. Questo errore può verificarsi se il sistema operativo, la o qualsiasi parte intermediaria (ad esempio Servizio AWS, un gateway NAT, un proxy, un sistema di bilanciamento del carico) non riesce a inviare i dati entro il tempo previsto dalla JVM. Poiché le cause sono molteplici, per trovare una soluzione è necessario conoscere il motivo per cui i dati non vengono restituiti.
Prova a eseguire un dump TCP per una connessione interessata nella periferia client della rete (ad esempio, dopo tutti i proxy che controlli).
[Se vedi che l' AWS endpoint sta inviando un `TCP RST` (reset), contatta il servizio interessato.](https://aws.amazon.com/contact-us/) Preparati a fornire la richiesta IDs e l'ora in cui si è verificato il problema. Il team di AWS supporto potrebbe inoltre trarre vantaggio dai [registri telefonici](logging-slf4j.md#sdk-java-logging-verbose) che mostrano esattamente quali byte vengono inviati e ricevuti dall'applicazione e quando.
## Come posso correggere l'errore «Impossibile eseguire la richiesta HTTP: timeout in attesa di connessione dal pool»?
Questo errore indica che una richiesta non può ottenere una connessione dal pool entro il tempo massimo specificato. Per risolvere il problema, ti consigliamo di [abilitare i parametri SDK lato client per pubblicare i parametri su Amazon](metrics.md). CloudWatch Le metriche HTTP possono aiutare a restringere la causa principale. I seguenti elementi descrivono le cause più comuni di questo errore.
+ **Perdita di connessione.** Puoi indagare su questo problema controllando `LeasedConcurrency``AvailableConcurrency`, e `MaxConcurrency` metriche. Se `LeasedConcurrency` aumenta fino a raggiungere l'`MaxConcurrency`obiettivo ma non diminuisce mai, potrebbe esserci una perdita di connessione. Una causa comune di una perdita di dati è che un'operazione di streaming, ad esempio un metodo S3, non viene chiusa. `getObject` [Consigliamo all'applicazione di leggere tutti i dati dal flusso di input il prima possibile e di chiudere il flusso di input in seguito.](best-practices.md#bestpractice2) La tabella seguente mostra come potrebbero apparire le metriche SDK per le perdite di connessione.
![\[Una schermata delle CloudWatch metriche che mostrano una probabile perdita di connessione.\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/images/JavaDevGuide-connection-leak-metrics-chart.png)
+ **Interruzione del pool di connessioni.**Ciò può verificarsi se la frequenza delle richieste è troppo elevata e la dimensione del pool di connessioni configurato non è in grado di soddisfare la richiesta. La dimensione predefinita del pool di connessioni è 50 e quando le connessioni nel pool raggiungono il massimo, il client HTTP mette in coda le richieste in arrivo finché le connessioni non diventano disponibili. Il grafico seguente mostra come potrebbero apparire le metriche SDK in caso di carenza di pool di connessioni.
![\[Una schermata delle CloudWatch metriche che mostra come potrebbe apparire la carenza di connessioni nei pool di connessioni.\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/images/JavaDevGuide-connection-pool-starvation-chart.png)
Per mitigare questo problema, prendi in considerazione l'idea di intraprendere una delle seguenti azioni.
+ Aumentare la dimensione del pool di connessioni,
+ Aumentare il timeout di acquisizione.
+ Rallenta la frequenza delle richieste.
Aumentando il numero massimo di connessioni, è possibile aumentare la velocità effettiva del client (a meno che l'interfaccia di rete non sia già completamente utilizzata). Tuttavia, alla fine è possibile raggiungere le limitazioni del sistema operativo relative al numero di descrittori di file utilizzati dal processo. Se utilizzi già completamente l'interfaccia di rete o non riesci ad aumentare ulteriormente il numero di connessioni, prova ad aumentare il timeout di acquisizione. Con l'aumento, avrai più tempo a disposizione per le richieste di acquisizione di una connessione prima del timeout. Se le connessioni non si liberano, le richieste successive continueranno a scadere.
Se non riesci a risolvere il problema utilizzando i primi due meccanismi, rallenta la frequenza delle richieste provando le seguenti opzioni.
+ Semplifica le tue richieste in modo che i grandi picchi di traffico non sovraccarichino il client.
+ Sii più efficiente con le chiamate a. Servizi AWS
+ Aumenta il numero di host che inviano richieste.
+ **I thread di I/O sono troppo occupati.** Questo vale solo se si utilizza un client SDK asincrono con. [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/http/nio/netty/NettyNioAsyncHttpClient.html) Se la `AvailableConcurrency` metrica non è bassa, ovvero indica che le connessioni sono disponibili nel pool, ma `ConcurrencyAcquireDuration` è elevata, è possibile che i thread non siano in grado di gestire le richieste. I/O Assicurati di non passare `Runnable:run` per un [futuro esecutore di completamento](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/client/config/SdkAdvancedAsyncClientOption.html#FUTURE_COMPLETION_EXECUTOR) e di non eseguire attività dispendiose in termini di tempo nella catena di completamento delle risposte future, poiché ciò può bloccare un I/O thread. In caso contrario, valuta la possibilità di aumentare il numero di I/O thread utilizzando il metodo. `[eventLoopGroupBuilder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.Builder.html#eventLoopGroupBuilder(software.amazon.awssdk.http.nio.netty.SdkEventLoopGroup.Builder))` Per riferimento, il numero predefinito di thread di I/O per un'`NettyNioAsyncHttpClient`istanza è il doppio del numero di core CPU dell'host.
+ **Latenza di handshake TLS elevata.** Se la `AvailableConcurrency` metrica è vicina a 0 ed `LeasedConcurrency` è inferiore a`MaxConcurrency`, è possibile che la latenza dell'handshake TLS sia elevata. Il grafico seguente mostra come potrebbero apparire le metriche SDK per un'elevata latenza di handshake TLS.
![\[Una schermata delle CloudWatch metriche che potrebbero indicare un'elevata latenza di handshake TLS.\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/images/JavaDevGuide-high-tls-latency-chart.png)
[Per i client HTTP offerti da Java SDK che non sono basati su CRT, provate ad abilitare i log TLS per risolvere i problemi TLS.](security-java-tls.md) [Per il client HTTP basato su CRT, prova ad AWS abilitare i log CRT.AWS](logging-slf4j.md#sdk-java-logging-verbose) [Se notate che l' AWS endpoint sembra impiegare molto tempo per eseguire un handshake TLS, contattate il servizio interessato.](https://aws.amazon.com/contact-us/)
## Come posso riparare un`NoClassDefFoundError`, or? `NoSuchMethodError` `NoSuchFieldError`
A `NoClassDefFoundError` indica che non è stato possibile caricare una classe in fase di esecuzione. Le due cause più comuni di questo errore sono:
+ la classe non esiste nel classpath perché nel classpath manca il JAR o nel classpath è presente una versione errata del JAR.
+ la classe non è stata caricata perché il suo inizializzatore statico ha generato un'eccezione.
Allo stesso modo, `NoSuchMethodError` s e `NoSuchFieldError` s in genere derivano da una versione JAR non corrispondente. Si consiglia di eseguire le seguenti operazioni.
1. **Controlla le tue dipendenze** per assicurarti di utilizzare la *stessa versione di tutti i jar SDK*. Il motivo più comune per cui non è possibile trovare una classe, un metodo o un campo è quando esegui l'aggiornamento a una nuova versione del client ma continui a utilizzare una vecchia versione di dipendenza SDK «condivisa». La nuova versione del client potrebbe tentare di utilizzare classi che esistono solo nelle dipendenze SDK «condivise» più recenti. Prova a eseguire `mvn dependency:tree` o `gradle dependencies` (per Gradle) a verificare che tutte le versioni della libreria SDK corrispondano. Per evitare completamente questo problema in futuro, consigliamo di utilizzare [BOM (Bill of Materials)](setup-project-maven.md#sdk-as-dependency) per gestire le versioni dei moduli SDK.
L'esempio seguente mostra un esempio di versioni SDK miste.
```
[INFO] +- software.amazon.awssdk:dynamodb:jar:2.20.00:compile
[INFO] | +- software.amazon.awssdk:aws-core:jar:2.13.19:compile
[INFO] +- software.amazon.awssdk:netty-nio-client:jar:2.20.00:compile
```
La versione di `dynamodb` è 2.20.00 e la versione di `aws-core` è 2.13.19. Anche la versione degli `aws-core` artefatti dovrebbe essere la 2.20.00.
1. **Controlla le istruzioni nelle prime fasi dei log** per vedere se una classe non riesce a caricarsi a causa di un errore di inizializzazione statico. La prima volta che la classe non riesce a caricarsi, potrebbe generare un'eccezione diversa e più utile che specifica il *motivo per cui* la classe non può essere caricata. Questa eccezione potenzialmente utile si verifica solo una volta, quindi le istruzioni di registro successive segnaleranno solo che la classe non è stata trovata.
1. **Controllate il processo di distribuzione** per assicurarvi che distribuisca effettivamente i file JAR richiesti insieme all'applicazione. È possibile che tu stia compilando con la versione corretta, ma il processo che crea il classpath per l'applicazione esclude una dipendenza richiesta.
## Come posso correggere un errore "`SignatureDoesNotMatch`" o l'errore «La firma della richiesta che abbiamo calcolato non corrisponde alla firma che hai fornito»?
Un `SignatureDoesNotMatch` errore indica che la firma generata da AWS SDK per Java e la firma generata da Servizio AWS non corrispondono. I seguenti elementi descrivono le cause potenziali.
+ Un delegato o un intermediario modifica la richiesta. Ad esempio, un proxy o un load balancer potrebbe modificare un'intestazione, un percorso o una stringa di query firmata dall'SDK.
+ Il servizio e l'SDK differiscono nel modo in cui codificano la richiesta quando ciascuno genera la stringa da firmare.
Per eseguire il debug di questo problema, ti consigliamo di [abilitare la registrazione di debug](logging-slf4j.md#sdk-debug-level-logging) per l'SDK. Prova a riprodurre l'errore e trova la richiesta canonica generata dall'SDK. Nel registro, la richiesta canonica è etichettata con `AWS4 Canonical Request: ...` e la stringa da firmare è etichettata. `AWS4 String to sign: ...`
Se non puoi abilitare il debug, ad esempio perché è riproducibile solo in produzione, aggiungi una logica all'applicazione che registra le informazioni sulla richiesta quando si verifica l'errore. È quindi possibile utilizzare tali informazioni per provare a replicare l'errore al di fuori della produzione in un test di integrazione con la registrazione di debug abilitata.
Dopo aver raccolto la richiesta canonica e la stringa da firmare, confrontale con la [specifica AWS Signature Version 4](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html) per determinare se ci sono problemi nel modo in cui l'SDK ha generato la stringa da firmare. Se qualcosa sembra sbagliato, puoi creare una [segnalazione di GitHub bug](https://github.com/aws/aws-sdk-java-v2/issues/new/choose) a. AWS SDK per Java
Se non appare nulla di sbagliato, puoi confrontare la stringa dell'SDK da firmare con la stringa per firmare che alcuni Servizi AWS restituiscono come parte della risposta all'errore (Amazon S3, ad esempio). Se questa opzione non è disponibile, [contatta il servizio interessato](https://aws.amazon.com/contact-us/) per vedere quale richiesta canonica e stringa da firmare hanno generato per il confronto. Questi confronti possono aiutare a identificare gli intermediari che potrebbero aver modificato la richiesta o le differenze di codifica tra il servizio e il client.
Per ulteriori informazioni di base sulla firma delle richieste, consulta [Firmare le richieste AWS API nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html) per l' AWS Identity and Access Management utente.
**Example di una richiesta canonica**
```
PUT
/Example-Bucket/Example-Object
partNumber=19&uploadId=string
amz-sdk-invocation-id:f8c2799d-367c-f024-e8fa-6ad6d0a1afb9
amz-sdk-request:attempt=1; max=4
content-encoding:aws-chunked
content-length:51
content-type:application/octet-stream
host:xxxxx
x-amz-content-sha256:STREAMING-UNSIGNED-PAYLOAD-TRAILER
x-amz-date:20240308T034733Z
x-amz-decoded-content-length:10
x-amz-sdk-checksum-algorithm:CRC32
x-amz-trailer:x-amz-checksum-crc32
```
**Example di una stringa da firmare**
```
AWS4-HMAC-SHA256
20240308T034435Z
20240308/us-east-1/s3/aws4_request
5f20a7604b1ef65dd89c333fd66736fdef9578d11a4f5d22d289597c387dc713
```
## Come posso correggere l'errore "`java.lang.IllegalStateException`: Connection pool shut down»?
Questo errore indica che il pool di connessioni HTTP Apache sottostante è stato chiuso. I seguenti elementi descrivono le cause potenziali.
+ **Il client SDK è stato chiuso prematuramente.**L'SDK chiude il pool di connessioni solo quando il client associato viene chiuso. Assicurati di non chiudere le risorse mentre sono in uso.
+ **Un `java.lang.Error` è stato lanciato.** Errori come quello che `OutOfMemoryError` causa la [chiusura](https://github.com/apache/httpcomponents-client/blob/6a741b4f8f23e6c5c7cc42c36c2acabfac19c3d6/httpclient/src/main/java/org/apache/http/impl/execchain/MainClientExec.java#L368) di un pool di connessioni HTTP di Apache. Esamina i log per individuare eventuali tracce dello stack di errori. Esamina anche il codice per individuare i punti in cui rileva `Throwable` s o `Error` s ma ingoia l'output che impedisce la comparsa dell'errore. Se il codice non riporta errori, riscrivilo in modo che le informazioni vengano registrate. Le informazioni registrate aiutano a determinare la causa principale dell'errore.
+ **Hai tentato di utilizzare il provider di credenziali restituito `DefaultCredentialsProvider#create()` dopo la sua chiusura**. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html#create()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html#create())restituisce un'istanza singleton, quindi se è chiusa e il codice chiama il `resolveCredentials` metodo, l'eccezione viene generata dopo la scadenza delle credenziali (o token) memorizzate nella cache.
Controlla il codice per individuare i punti in cui `DefaultCredentialsProvider` è chiuso, come illustrato negli esempi seguenti.
+ L'istanza singleton viene chiusa chiamando `DefaultCredentialsProvider#close().`
```
DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider.create(); // Singleton instance returned.
AwsCredentials credentials = defaultCredentialsProvider.resolveCredentials();
// Make calls to Servizi AWS.
defaultCredentialsProvider.close(); // Explicit close.
// Make calls to Servizi AWS.
// After the credentials expire, either of the following calls eventually results in a "Connection pool shut down" exception.
credentials = defaultCredentialsProvider.resolveCredentials();
// Or
credentials = DefaultCredentialsProvider.create().resolveCredentials();
```
+ Invoca `DefaultCredentialsProvider#create()` in un blocco. try-with-resources
```
try (DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider.create()) {
AwsCredentials credentials = defaultCredentialsProvider.resolveCredentials();
// Make calls to Servizi AWS.
} // After the try-with-resources block exits, the singleton DefaultCredentialsProvider is closed.
// Make calls to Servizi AWS.
DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider.create(); // The closed singleton instance is returned.
// If the credentials (or token) has expired, the following call results in the error.
AwsCredentials credentials = defaultCredentialsProvider.resolveCredentials();
```
Crea una nuova istanza non singleton chiamando `DefaultCredentialsProvider.builder().build()` se il tuo codice ha chiuso l'istanza singleton e devi risolvere le credenziali utilizzando un. `DefaultCredentialsProvider`
## Come posso risolvere il problema «Impossibile caricare le credenziali da nessuno dei provider della catena «? AwsCredentialsProviderChain
Questo errore indica che non è AWS SDK for Java 2.x riuscito a trovare AWS credenziali valide tramite nessuno dei provider di credenziali nella catena di provider di credenziali predefinita. L'SDK cerca automaticamente le credenziali in un ordine specifico e questo errore si verifica quando tutti i provider della catena non forniscono credenziali valide.
Il messaggio di errore completo in genere ha il seguente aspetto (terminazioni di riga e rientri aggiunti per migliorare la leggibilità):
```
Unable to load credentials from any of the providers in the chain AwsCredentialsProviderChain(
credentialsProviders=[
SystemPropertyCredentialsProvider(),
EnvironmentVariableCredentialsProvider(),
WebIdentityTokenCredentialsProvider(),
ProfileCredentialsProvider(profileName=default, profileFile=ProfileFile(sections=[])),
ContainerCredentialsProvider(),
InstanceProfileCredentialsProvider()
]) : [
SystemPropertyCredentialsProvider(): Unable to load credentials from system settings.
Access key must be specified either via environment variable (AWS_ACCESS_KEY_ID)
or system property (aws.accessKeyId).,
EnvironmentVariableCredentialsProvider(): Unable to load credentials from system settings.
Access key must be specified either via environment variable (AWS_ACCESS_KEY_ID)
or system property (aws.accessKeyId).,
WebIdentityTokenCredentialsProvider(): To use web identity tokens, the 'sts' service module
must be on the class path.,
ProfileCredentialsProvider(profileName=default, profileFile=ProfileFile(sections=[])):
Profile file contained no credentials for profile 'default': ProfileFile(sections=[]),
ContainerCredentialsProvider(): Cannot fetch credentials from container - neither
AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI environment
variables are set.,
InstanceProfileCredentialsProvider(): Failed to load credentials from IMDS.]
```
### Cause e soluzioni comuni
#### Rivedi la configurazione delle credenziali
Quando utilizzi il provider di credenziali predefinito (chiamando `ServiceClient.create()` senza configurare esplicitamente le credenziali), l'SDK cerca le credenziali in un ordine specifico. Scopri [come funziona la catena di provider di credenziali predefinita](credentials-chain.md) per capire quali fonti di credenziali vengono controllate dall'SDK e in quale ordine.
Assicurati che il metodo di configurazione delle credenziali che intendi utilizzare sia configurato correttamente nel tuo ambiente:
##### Per le istanze Amazon EC2
+ **Verifica il ruolo IAM:** verifica che un ruolo IAM sia collegato alla tua istanza.
+ Guasti **IMDS intermittenti: se si verificano guasti** intermittenti (che in genere durano alcune centinaia di millisecondi), di solito ciò indica problemi transitori di rete che raggiungono l'Instance Metadata Service (IMDS).
Soluzioni:
+ Abilita [la registrazione di debug per analizzare la tempistica e la frequenza degli errori](logging-slf4j.md#sdk-debug-level-logging)
+ Valuta la possibilità di implementare la logica di ripetizione dei tentativi nella tua applicazione per gli errori relativi alle credenziali
+ Verifica la presenza di problemi di connettività di rete tra l'istanza e l'endpoint IMDS
##### Per ambienti container
Verifica che i ruoli delle attività (Amazon ECS) o gli account di servizio (Amazon EKS) siano configurati e che le variabili di ambiente richieste siano impostate.
##### Per lo sviluppo locale
Verifica che le variabili di ambiente, i file di credenziali o la configurazione di IAM Identity Center siano attivi.
##### Per la federazione delle identità web
+ **Verifica della configurazione:** verifica che il file del token di identità Web esista e che le variabili di ambiente richieste siano configurate.
+ **Dipendenza del modulo STS mancante:** se vedi l'errore`To use web identity tokens, the 'sts' service module must be on the class path`, devi aggiungere il modulo STS come dipendenza. Questo è comune quando si utilizza Amazon EKS Pod Identity o un'altra autenticazione con token di identità Web.
Soluzione: aggiungi il modulo STS alle dipendenze del progetto:
+
```
software.amazon.awssdk
sts
```
Per alcuni servizi, potresti aver bisogno anche della `aws-query-protocol` dipendenza:
```
software.amazon.awssdk
aws-query-protocol
```
#### Problemi di connettività di rete o proxy
Se riscontri `Connection refused` errori nella catena di fornitori di credenziali, in genere ciò indica problemi di connettività di rete quando l'SDK tenta di raggiungere AWS gli endpoint.
**Soluzioni:**
+ Verifica la configurazione del proxy se utilizzi un server proxy
+ Verifica che la tua rete consenta connessioni HTTPS in uscita verso gli AWS endpoint
+ Abilita la [registrazione di debug per visualizzare i tentativi di connessione](logging-slf4j.md#sdk-debug-level-logging) dettagliati
+ Testa la connettività utilizzando strumenti come la verifica dell'accesso `curl` alla rete agli endpoint AWS
# Riduci i tempi di avvio dell'SDK per AWS Lambda
Uno degli obiettivi di AWS SDK for Java 2.x è ridurre la latenza di avvio delle funzioni AWS Lambda . L'SDK contiene modifiche che riducono i tempi di avvio, discusse alla fine di questo argomento.
Innanzitutto, questo argomento si concentra sulle modifiche che è possibile apportare per ridurre i tempi di avvio a freddo. Queste includono le modifiche alla struttura del codice e alla configurazione dei client di servizio.
## Utilizzate un client AWS HTTP basato su CRT
Per lavorare con AWS Lambda, consigliamo il [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html)per scenari sincroni e il [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/AwsCrtAsyncHttpClient.html)per scenari asincroni.
L'[Configurazione AWS dei client HTTP basati su CRT](http-configuration-crt.md)argomento di questa guida descrive i vantaggi dell'utilizzo dei client HTTP, come aggiungere la dipendenza e come configurarne l'utilizzo da parte dei client di servizio.
## Rimuovi le dipendenze inutilizzate del client HTTP
Oltre all'uso esplicito di un client AWS basato su CRT, puoi rimuovere altri client HTTP che l'SDK integra per impostazione predefinita. Il tempo di avvio di Lambda si riduce quando è necessario caricare meno librerie, quindi è necessario rimuovere tutti gli artefatti inutilizzati che la JVM deve caricare.
Il seguente frammento di un `pom.xml` file Maven mostra l'esclusione del client HTTP basato su Apache e del client HTTP basato su Netty. (Questi client non sono necessari quando si utilizza un client basato su CRT). AWS Questo esempio esclude gli artefatti del client HTTP dalla dipendenza del client S3 e aggiunge l'`aws-crt-client`artefatto per consentire l'accesso ai client HTTP basati su CRT. AWS
```
2.27.21
software.amazon.awssdk
bom
${aws.java.sdk.version}
pom
import
software.amazon.awssdk
aws-crt-client
software.amazon.awssdk
s3
software.amazon.awssdk
netty-nio-client
software.amazon.awssdk
apache-client
```
**Nota**
Aggiungi l'``elemento a tutte le dipendenze del client di servizio nel tuo file. `pom.xml`
## Configura i client di servizio per abbreviare le ricerche
**Specificare una regione**
Quando crei un client di servizio, chiama il `region` metodo sul service client builder. Questo accorcia il [processo di ricerca regionale predefinito dell'SDK, che controlla le](region-selection.md#default-region-provider-chain) informazioni in diversi punti. Regione AWS
Per mantenere il codice Lambda indipendente dalla regione, usa il codice seguente all'interno del `region` metodo. Questo codice accede alla variabile di `AWS_REGION` ambiente impostata dal contenitore Lambda.
```
Region.of(System.getenv(SdkSystemSetting.AWS_REGION.environmentVariable()))
```
**Utilizzo della `EnvironmentVariableCredentialProvider`**
Analogamente al comportamento di ricerca predefinito per le informazioni sulla regione, l'SDK cerca le credenziali in diversi punti. Specificando [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/EnvironmentVariableCredentialsProvider.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/EnvironmentVariableCredentialsProvider.html)quando si crea un client di servizio, si risparmia tempo nel processo di ricerca delle credenziali dell'SDK.
L'utilizzo di questo provider di credenziali consente di utilizzare il codice nelle Lambda funzioni, ma potrebbe non funzionare su altri sistemi. Amazon EC2
Se a un certo punto intendi utilizzare [Lambda SnapStart per Java](#lambda-quick-snapstart), dovresti fare affidamento sulla catena di provider di credenziali predefinita per cercare le credenziali. Se specificate la`EnvironmentVariableCredentialsProvider`, la ricerca iniziale delle credenziali funziona, ma quando SnapStart è attivata, il [runtime Java imposta le variabili di ambiente delle credenziali del contenitore](https://docs.aws.amazon.com/lambda/latest/dg/snapstart-activate.html#snapstart-credentials). Al momento dell'attivazione, le variabili di ambiente utilizzate dalle variabili di ambiente `EnvironmentVariableCredentialsProvider` —access key— non sono disponibili per Java SDK.
Il seguente frammento di codice mostra un client di servizio S3 configurato in modo appropriato per l'uso in un ambiente Lambda.
```
S3Client s3Client = S3Client.builder()
.region(Region.of(System.getenv(SdkSystemSetting.AWS_REGION.environmentVariable())))
.credentialsProvider(EnvironmentVariableCredentialsProvider.create())
.httpClient(AwsCrtHttpClient.builder().build())
.build();
```
## Inizializza il client SDK all'esterno del gestore di funzioni Lambda
Consigliamo di inizializzare un client SDK al di fuori del metodo del gestore Lambda. In questo modo, se il contesto di esecuzione viene riutilizzato, l'inizializzazione del client di servizio può essere ignorata. Riutilizzando l'istanza del client e le relative connessioni, le successive invocazioni del metodo handler avvengono più rapidamente.
Nell'esempio seguente, l'`S3Client`istanza viene inizializzata nel costruttore utilizzando un metodo factory statico. Se il contenitore gestito dall'ambiente Lambda viene riutilizzato, l'istanza inizializzata `S3Client` viene riutilizzata.
```
public class App implements RequestHandler {
private final S3Client s3Client;
public App() {
s3Client = DependencyFactory.s3Client();
}
@Override
public Object handle Request(final Object input, final Context context) {
ListBucketResponse response = s3Client.listBuckets();
// Process the response.
}
}
```
## Riduci al minimo l'iniezione di dipendenza
I framework di Dependency Injection (DI) potrebbero richiedere più tempo per completare il processo di configurazione. Potrebbero inoltre richiedere dipendenze aggiuntive, il cui caricamento richiede tempo.
[Se è necessario un framework DI, consigliamo di utilizzare framework DI leggeri come Dagger.](https://dagger.dev/dev-guide/)
## Usa un targeting Maven Archetype AWS Lambda
Il team AWS Java SDK ha sviluppato un [modello Maven Archetype](https://github.com/aws/aws-sdk-java-v2/tree/master/archetypes/archetype-lambda) per avviare un progetto Lambda con tempi di avvio minimi. Puoi creare un progetto Maven a partire dall'archetipo e sapere che le dipendenze sono configurate in modo appropriato per l'ambiente Lambda.
[Per saperne di più sull'archetipo e illustrare un esempio di implementazione, consulta questo post sul blog.](https://aws.amazon.com/blogs/developer/bootstrapping-a-java-lambda-application-with-minimal-aws-java-sdk-startup-time-using-maven/)
## Prendi in considerazione Lambda SnapStart per Java
Se i requisiti di runtime sono compatibili, AWS offre [Lambda SnapStart per](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html) Java. Lambda SnapStart è una soluzione basata sull'infrastruttura che migliora le prestazioni di avvio per le funzioni Java. Quando pubblichi una nuova versione di una funzione, Lambda la SnapStart inizializza e scatta un'istantanea crittografata e immutabile della memoria e dello stato del disco. SnapStart quindi memorizza l'istantanea nella cache per riutilizzarla.
## Modifiche alla versione 2.x che influiscono sul tempo di avvio
Oltre alle modifiche apportate al codice, la versione 2.x dell'SDK for Java include tre modifiche principali che riducono i tempi di avvio:
+ Uso di [jackson-jr](https://github.com/FasterXML/jackson-jr), una libreria di serializzazione che migliora i tempi di inizializzazione
+ Uso delle librerie [java.time](https://docs.oracle.com/javase/8/docs/api/index.html?java/time.html) per oggetti di data e ora, che fanno parte del JDK
+ Uso di [SLF4j](https://www.slf4j.org/) per una facciata adibita a registrazione
## Risorse aggiuntive
La Guida per gli AWS Lambda sviluppatori contiene una [sezione sulle migliori pratiche](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) per lo sviluppo di funzioni Lambda che non è specifica per Java.
[Per un esempio di creazione di un'applicazione nativa per il cloud in Java che utilizza AWS Lambda, consulta il contenuto di questo workshop.](https://github.com/aws-samples/aws-lambda-java-workshop) Il workshop discute dell'ottimizzazione delle prestazioni e di altre best practice.
Puoi prendere in considerazione l'utilizzo di immagini statiche compilate in anticipo per ridurre la latenza di avvio. Ad esempio, puoi utilizzare l'SDK per Java 2.x e Maven per [creare](setup-project-graalvm.md) un'immagine nativa GraalVM.
# Implementare `ContentStreamProvider` nel AWS SDK for Java 2.x
`ContentStreamProvider`è un'astrazione utilizzata in per consentire letture multiple dei AWS SDK for Java 2.x dati di input. Questo argomento spiega come implementarlo `ContentStreamProvider` correttamente per le applicazioni.
L'SDK for Java 2.x utilizza `ContentStreamProvider#newStream()` il metodo ogni volta che deve leggere un intero flusso. Affinché ciò funzioni per l'intero flusso, lo stream restituito deve essere sempre all'inizio del contenuto e deve contenere gli stessi dati.
Nelle sezioni seguenti, forniamo tre approcci per implementare correttamente questo comportamento.
## Uso di `mark()` e `reset()`
Nell'esempio seguente, utilizziamo `mark(int)` il costruttore prima che inizi la lettura per assicurarci di poter ripristinare lo stream all'inizio. Per ogni invocazione di `newStream()` resettiamo lo stream:
```
public class MyContentStreamProvider implements ContentStreamProvider {
private InputStream contentStream;
public MyContentStreamProvider(InputStream contentStream) {
this.contentStream = contentStream;
this.contentStream.mark(MAX_LEN);
}
@Override
public InputStream newStream() {
contentStream.reset();
return contentStream;
}
}
```
## Usa il buffering se `mark()` e `reset()` non sono disponibili
Se il tuo stream non supporta `reset()` direttamente `mark()` e direttamente, puoi comunque utilizzare la soluzione mostrata in precedenza, racchiudendo prima lo stream in: `BufferedInputStream`
```
public class MyContentStreamProvider implements ContentStreamProvider {
private BufferedReader contentStream;
public MyContentStreamProvider(InputStream contentStream) {
this.contentStream = new BufferedInputStream(contentStream);
this.contentStream.mark(MAX_LEN);
}
@Override
public InputStream newStream() {
contentStream.reset();
return contentStream;
}
}
```
## Crea nuovi stream
Un approccio più semplice consiste semplicemente nell'ottenere un nuovo flusso di dati a ogni chiamata e chiudere quello precedente:
```
public class MyContentStreamProvider implements ContentStreamProvider {
private InputStream contentStream;
@Override
public InputStream newStream() {
if (contentStream != null) {
contentStream.close();
}
contentStream = openStream();
return contentStream;
}
}
```
# Imposta il TTL JVM per le ricerche dei nomi DNS
Java Virtual Machine (JVM) memorizza nella cache le ricerche dei nomi DNS. Quando la JVM risolve un nome host in un indirizzo IP, memorizza l'indirizzo IP nella cache per un periodo di tempo specificato, noto come (TTL). *time-to-live*
Poiché AWS le risorse utilizzano voci di nomi DNS che cambiano occasionalmente, si consiglia di configurare la JVM con un valore TTL di 5 secondi. Questo garantisce che quando l'indirizzo IP di una risorsa cambia, l'applicazione potrà ricevere e utilizzare il nuovo indirizzo IP della risorsa richiedendo il DNS.
In alcune configurazioni Java, il TTL predefinito di JVM è impostato in modo da *non* aggiornare mai le voci DNS finché JVM non viene riavviato. Pertanto, se l'indirizzo IP di una AWS risorsa cambia mentre l'applicazione è ancora in esecuzione, non sarà possibile utilizzare tale risorsa finché non si *riavvia manualmente* la JVM e le informazioni IP memorizzate nella cache non vengono aggiornate. In questo caso, è fondamentale impostare il valore TTL della JVM in modo che aggiorni periodicamente le informazioni IP memorizzate nella cache.
## Come impostare il TTL JVM
[Per modificare il TTL della JVM, imposta il valore della proprietà di sicurezza networkaddress.cache.ttl.](https://docs.oracle.com/en/java/javase/17/core/java-networking.html#GUID-A680DADB-C4C1-40F1-B568-D9A97C917F5D) Nota che `networkaddress.cache.ttl` è una proprietà di *sicurezza, non una proprietà di* sistema, cioè non può essere impostata con il flag della riga di comando. `-D`
### Opzione 1: impostala a livello di codice nella tua applicazione
Effettua una chiamata nelle [https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/security/Security.html](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/security/Security.html)prime fasi di avvio dell'applicazione, prima della creazione di qualsiasi client AWS SDK e prima di effettuare qualsiasi richiesta di rete:
```
import java.security.Security;
public class MyApplication {
public static void main(String[] args) {
Security.setProperty("networkaddress.cache.ttl", "5");
// ... create SDK clients and run application
}
}
```
### Opzione 2: impostala nel file java.security
Imposta la `networkaddress.cache.ttl` proprietà nel `$JAVA_HOME/jre/lib/security/java.security` file per Java 8 o nel `$JAVA_HOME/conf/security/java.security` file per Java 11 o versioni successive.
Quello che segue è un frammento di un `java.security` file che mostra la cache TTL impostata su 5 secondi.
```
#
# The Java-level namelookup cache policy for successful lookups:
#
# any negative value: caching forever
# any positive value: the number of seconds to cache an address for
# zero: do not cache
#
...
networkaddress.cache.ttl=5
...
```
Tutte le applicazioni eseguite sulla JVM rappresentata dalla variabile di `$JAVA_HOME` ambiente utilizzano questa impostazione.
### Opzione 3: utilizzare il fallback delle proprietà del sistema JDK (riga di comando)
Se non è possibile modificare la configurazione o il codice di sicurezza, è possibile utilizzare le proprietà del sistema JDK. Queste fungono da fallback se non è definita alcuna proprietà di sicurezza.
+ `sun.net.inetaddr.ttl`— Controlla le ricerche riuscite (TTL positivo)
+ `sun.net.inetaddr.negative.ttl`— Controlla le ricerche non riuscite (TTL negativo)
```
java -Dsun.net.inetaddr.ttl=5 -Dsun.net.inetaddr.negative.ttl=1 -jar myapp.jar
```
**Nota**
Si tratta di proprietà interne a JDK documentate nel riferimento [Oracle Java 8 Networking Properties come proprietà](https://docs.oracle.com/javase/8/docs/technotes/guides/net/properties.html) private che «potrebbero non essere supportate nelle versioni future». Utilizzare le opzioni 1-2 quando possibile.
# Lavora con HTTP/2 in AWS SDK per Java
HTTP/2 è una revisione principale del protocollo HTTP. Questa nuova versione presenta diversi miglioramenti per aumentare le prestazioni:
+ La codifica dei dati binari offre un trasferimento dei dati più efficace.
+ La compressione delle intestazioni riduce i byte in eccesso scaricati dal client, in modo che ottenga i contenuti in modo più rapido. Questo è particolarmente utile per i client mobili che sono già vincolati dalla larghezza di banda.
+ La comunicazione asincrona bidirezionale (multiplexing) consente più richieste e messaggi di risposta tra il client e AWS di essere attivi contemporaneamente su una singola connessione, anziché su più connessioni, il che migliora le prestazioni.
Gli sviluppatori che effettuano l'aggiornamento alla versione più recente SDKs utilizzeranno automaticamente HTTP/2 quando è supportato dal servizio con cui stanno lavorando. Le nuove interfacce di programmazione sfruttano in modo ottimale le caratteristiche di HTTP/2 e offrono nuovi modi per creare applicazioni.
La versione AWS SDK per Java 2.x presenta nuove funzionalità APIs per lo streaming di eventi che implementano il protocollo HTTP/2. Per esempi di come utilizzare queste novità APIs, consulta [Lavorare con Kinesis](examples-kinesis.md).