La AWS SDK per Java 1.x è stata raggiunta end-of-support il 31 dicembre 2025. Ti consigliamo di eseguire la migrazione a per continuare [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html)a ricevere nuove funzionalità, miglioramenti della disponibilità e aggiornamenti di sicurezza.
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à.
# Utilizzando il AWS SDK per Java
Questa sezione fornisce importanti informazioni generali sulla programmazione e si applicano a tutti i servizi AWS SDK per Java che è possibile utilizzare con l'SDK.
[Per informazioni ed esempi di programmazione specifici del servizio (per Amazon EC2,, ecc.) Amazon S3Amazon SWF, consulta AWS SDK per Java Esempi di codice.](prog-services.md)
**Topics**
+ [
# Migliori pratiche per AWS lo sviluppo con AWS SDK per Java
](best-practices.md)
+ [
# Creazione di client del servizio
](creating-clients.md)
+ [Fornire credenziali temporanee](credentials.md)
+ [
# Regione AWS Selezione
](java-dg-region-selection.md)
+ [
# Gestione delle eccezioni
](java-dg-exceptions.md)
+ [
# Programmazione asincrona
](basics-async.md)
+ [
# AWS SDK per Java Registrazione delle chiamate
](java-dg-logging.md)
+ [
# Configurazione del client
](section-client-configuration.md)
+ [
# Policy di controllo degli accessi
](java-dg-access-control.md)
+ [
# Imposta il TTL JVM per le ricerche dei nomi DNS
](jvm-ttl-dns.md)
+ [
# Abilitazione delle metriche per AWS SDK per Java
](generating-sdk-metrics.md)
# Migliori pratiche per AWS lo sviluppo con AWS SDK per Java
Le seguenti best practice possono aiutarti a evitare problemi o problemi durante lo sviluppo di AWS applicazioni con. AWS SDK per Java Abbiamo organizzato le migliori pratiche per servizio.
## S3
### Evita ResetExceptions
Quando carichi oggetti utilizzando gli Amazon S3 stream (tramite un `AmazonS3` client o`TransferManager`), potresti riscontrare problemi di connettività di rete o di timeout. Per impostazione predefinita, i AWS SDK per Java tentativi di riprovare i trasferimenti non sono riusciti contrassegnando il flusso di input prima dell'inizio di un trasferimento e quindi reimpostandolo prima di riprovare.
Se lo stream non supporta mark and reset, l'SDK genera un messaggio [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)quando si verificano errori temporanei e i nuovi tentativi sono abilitati.
**Procedura consigliata**
Ti consigliamo di utilizzare stream che supportano le operazioni di mark e reset.
Il modo più affidabile per evitare a [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)è fornire dati utilizzando un [File](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) or [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html), che AWS SDK per Java possono gestire senza essere vincolati dai limiti di marcatura e ripristino.
Se lo stream non è un [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html)formato ma supporta mark and reset, puoi impostare il limite dei mark utilizzando il `setReadLimit` metodo di. [RequestClientOptions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/RequestClientOptions.html) Il suo valore predefinito è 128 KB. L'impostazione del valore del limite di lettura su *un byte maggiore della dimensione dello stream* eviterà in modo affidabile un. [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)
Ad esempio, se la dimensione massima prevista di uno stream è 100.000 byte, imposta il limite di lettura su 100.001 (100.000 \$1 1) byte. La marcatura e il ripristino funzioneranno sempre per 100.000 byte o meno. Tieni presente che ciò potrebbe far sì che alcuni stream inseriscano nel buffer quel numero di byte nella memoria.
# Creazione di client del servizio
Per effettuare richieste a Amazon Web Services, devi prima creare un oggetto client di servizio. Il metodo consigliato è utilizzare il service client builder.
Ciascuno Servizio AWS ha un'interfaccia di servizio con metodi per ogni azione nell'API del servizio. Ad esempio, viene denominata l'interfaccia di servizio per DynamoDB. [AmazonDynamoDBClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClient.html) Ogni interfaccia di servizio dispone di un client builder corrispondente che è possibile utilizzare per creare un'implementazione dell'interfaccia di servizio. [La classe client builder for DynamoDB è denominata Builder. AmazonDynamo DBClient](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClientBuilder.html)
## Ottenere un generatore client
Per ottenere un'istanza del client builder, utilizzate il metodo static factory`standard`, come illustrato nell'esempio seguente.
```
AmazonDynamoDBClientBuilder builder = AmazonDynamoDBClientBuilder.standard();
```
Una volta che hai un builder, puoi personalizzare le proprietà del client utilizzando molti setter fluenti nell'API del builder. Ad esempio, puoi impostare un'area personalizzata e un provider di credenziali personalizzate, come segue.
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
**Nota**
I `withXXX` metodi fluent restituiscono l'`builder`oggetto in modo da poter concatenare le chiamate ai metodi per comodità e per rendere il codice più leggibile. Dopo aver configurato le proprietà desiderate, puoi chiamare il metodo `build` per creare il client. Una volta creato, un client è immutabile e qualsiasi chiamata a `setRegion` o avrà esito negativo. `setEndpoint`
Un builder può creare più client con la stessa configurazione. Quando scrivi la tua applicazione, tieni presente che il builder è mutabile e non thread-safe.
Il codice seguente utilizza il builder come factory per le istanze dei client.
```
public class DynamoDBClientFactory {
private final AmazonDynamoDBClientBuilder builder =
AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"));
public AmazonDynamoDB createClient() {
return builder.build();
}
}
```
[Il builder espone anche i setter fluenti per [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)e e un elenco personalizzato di [RequestMetricCollector](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/RequestMetricCollector.html)2. RequestHandler](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/RequestHandler2.html)
Di seguito è riportato un esempio completo che sovrascrive tutte le proprietà configurabili.
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.withClientConfiguration(new ClientConfiguration().withRequestTimeout(5000))
.withMetricsCollector(new MyCustomMetricsCollector())
.withRequestHandlers(new MyCustomRequestHandler(), new MyOtherCustomRequestHandler)
.build();
```
## Creazione di client asincroni
AWS SDK per Java Dispone di client asincroni (o asincroni) per ogni servizio (tranne Amazon S3) e un generatore di client asincroni corrispondente per ogni servizio.
### Per creare un client DynamoDB asincrono con il valore predefinito ExecutorService
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
Oltre alle opzioni di configurazione supportate dal generatore di client sincroni (o sincronizzati), il client asincrono consente di impostare una configurazione personalizzata [ExecutorFactory](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/client/builder/ExecutorFactory.html)per modificare le impostazioni utilizzate dal client asincrono. `ExecutorService` `ExecutorFactory`è un'interfaccia funzionale, quindi interagisce con le espressioni lambda e i riferimenti ai metodi di Java 8.
### Per creare un client asincrono con un executor personalizzato
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withExecutorFactory(() -> Executors.newFixedThreadPool(10))
.build();
```
## Usando DefaultClient
Sia i costruttori di client di sincronizzazione che quelli asincroni hanno un altro metodo di fabbrica denominato. `defaultClient` Questo metodo crea un client di servizio con la configurazione predefinita, utilizzando la catena di provider predefinita per caricare le credenziali e il. Regione AWS Se non è possibile determinare le credenziali o la regione dall'ambiente di esecuzione dell'applicazione, la chiamata a `defaultClient` non riesce. Per ulteriori informazioni su come vengono [AWS determinate le credenziali e l'area geografica, vedere Working with](credentials.md) Credentials and [Regione AWS Selection](java-dg-region-selection.md).
### Per creare un client di servizio predefinito
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
```
## Ciclo di vita del client
I client di servizio nell'SDK sono thread-safe e, per ottenere prestazioni ottimali, dovresti trattarli come oggetti di lunga durata. Ogni client dispone di una propria risorsa di pool di connessioni. Chiudi esplicitamente i client quando non sono più necessari per evitare perdite di risorse.
Per chiudere in modo esplicito un client, chiamate il metodo. `shutdown` Dopo la chiamata`shutdown`, tutte le risorse del client vengono rilasciate e il client è inutilizzabile.
### Per chiudere un client
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.shutdown();
// Client is now unusable
```
# Fornire credenziali temporanee a AWS SDK per Java
Per effettuare richieste a Amazon Web Services, è necessario fornire credenziali AWS temporanee AWS SDK per Java da utilizzare quando chiama i servizi. Questa operazione può essere eseguita nei modi seguenti:
+ Utilizzando la catena di provider delle credenziali predefinita *(scelta consigliata)*.
+ Utilizzando un provider di credenziali o catena di provider specifica (o creando la propria).
+ Fornisci tu stesso le credenziali temporanee nel codice.
## Utilizzo della catena di provider delle credenziali predefinita
[Quando inizializzate un nuovo client di servizio senza fornire alcun argomento, AWS SDK per Java tenta di trovare credenziali temporanee utilizzando la *catena di fornitori di credenziali predefinita* implementata dalla classe Default. AWSCredentials ProviderChain](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/DefaultAWSCredentialsProviderChain.html) La catena di provider delle credenziali predefinita cerca le credenziali in questo ordine:
1. **Variabili di ambiente** -`AWS_ACCESS_KEY_ID`, or, e`AWS_SECRET_KEY`. `AWS_SECRET_ACCESS_KEY` `AWS_SESSION_TOKEN` AWS SDK per Java utilizza la [EnvironmentVariableCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EnvironmentVariableCredentialsProvider.html)classe per caricare queste credenziali.
1. **Proprietà del sistema Java** -`aws.accessKeyId`, `aws.secretKey` (ma non`aws.secretAccessKey`), e`aws.sessionToken`. li AWS SDK per Java utilizza [SystemPropertiesCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/SystemPropertiesCredentialsProvider.html)per caricare queste credenziali.
1. **Credenziali Web Identity Token** dall'ambiente o dal contenitore.
1. **Il file di profili di credenziali predefinito**, in genere situato in `~/.aws/credentials` (la posizione può variare in base alla piattaforma) e condiviso da molti utenti AWS SDKs e da. AWS CLI AWS SDK per Java Utilizza il [ProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/profile/ProfileCredentialsProvider.html)per caricare queste credenziali.
È possibile creare un file di credenziali utilizzando il `aws configure` AWS CLI comando fornito da oppure modificarlo con un editor di testo. Per informazioni sul formato del file delle credenziali, consulta Formato del file [AWS delle credenziali](#credentials-file-format).
1. **Credenziali del contenitore Amazon ECS**: caricate da Amazon ECS se la variabile `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` di ambiente è impostata. Le AWS SDK per Java utilizza per caricare queste [ContainerCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/ContainerCredentialsProvider.html)credenziali. È possibile specificare l'indirizzo IP per questo valore.
1. **Credenziali del profilo di istanza**: utilizzate sulle istanze EC2 e fornite tramite il Amazon EC2 servizio di metadati. Le AWS SDK per Java utilizza per caricare queste [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)credenziali. È possibile specificare l'indirizzo IP per questo valore.
**Nota**
Le credenziali del profilo di istanza vengono utilizzate solo se non `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` sono impostate. Per ulteriori informazioni, consulta [EC2ContainerCredentialsProviderWrapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EC2ContainerCredentialsProviderWrapper.html).
### Imposta credenziali temporanee
Per poter utilizzare le credenziali AWS temporanee, devono essere impostate in *almeno una delle* posizioni precedenti. Per informazioni sull'impostazione delle credenziali, consulta i seguenti argomenti:
+ Per specificare le credenziali nell'*ambiente* o nel file dei *profili di credenziali* predefinito, vedere. [Configurare le credenziali temporanee](setup-credentials.md#setup-credentials-setting)
+ Per impostare *proprietà del sistema* Java, consulta il tutorial sulle [proprietà del sistema](http://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) nel sito Web dei *tutorial Java* ufficiale.
+ Per configurare e utilizzare *le credenziali del profilo di istanza* con le tue istanze EC2, consulta [Using IAM Roles to Grant Access to Resources](java-dg-roles.md) on. AWS Amazon EC2
### Imposta un profilo di credenziali alternativo
AWS SDK per Java Utilizza il profilo *predefinito* per impostazione predefinita, ma esistono modi per personalizzare il profilo proveniente dal file delle credenziali.
È possibile utilizzare la variabile AWS di ambiente Profile per modificare il profilo caricato dall'SDK.
*Ad esempio, su Linux, macOS o Unix è necessario eseguire il comando seguente per modificare il profilo in MyProfile.*
```
export AWS_PROFILE="myProfile"
```
In Windows si utilizzerebbe quanto segue.
```
set AWS_PROFILE="myProfile"
```
L'impostazione della variabile di `AWS_PROFILE` ambiente influisce sul caricamento delle credenziali per tutti gli strumenti AWS SDKs e strumenti ufficialmente supportati (inclusi i AWS CLI e i AWS Tools for Windows PowerShell). Per modificare solo il profilo di un'applicazione Java, potete `aws.profile` invece utilizzare la proprietà di sistema.
**Nota**
La variabile di ambiente prevale sulla proprietà di sistema.
### Imposta una posizione alternativa per il file delle credenziali
AWS SDK per Java Carica automaticamente le credenziali AWS temporanee dalla posizione predefinita del file delle credenziali. Tuttavia, puoi anche specificare il percorso impostando la variabile di ambiente `AWS_CREDENTIAL_PROFILES_FILE` con il percorso completo al file delle credenziali.
È possibile utilizzare questa funzionalità per modificare temporaneamente la posizione in cui AWS SDK per Java cerca il file delle credenziali (ad esempio, impostando questa variabile con la riga di comando). In alternativa, puoi impostare la variabile di ambiente nell'ambiente utente o di sistema per modificarla a livello di utente o di sistema.
#### Per ignorare il percorso del file delle credenziali predefinito
+ Imposta la variabile di `AWS_CREDENTIAL_PROFILES_FILE` ambiente sulla posizione del file delle AWS credenziali.
+ Su Linux, macOS o Unix, usa:
```
export AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
+ In Windows, usa:
```
set AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
### `Credentials`formato di file
Seguendo le [istruzioni riportate nella configurazione di base](signup-create-iam-user.md#setup-temp-creds) di questa guida, il file delle credenziali dovrebbe avere il seguente formato di base.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
[profile2]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
Il nome del profilo è specificato tra parentesi quadre (ad esempio, `[default]`), seguito dai campi configurabili nel profilo come coppie chiave-valore. Nel `credentials` file possono essere presenti più profili, che possono essere aggiunti o modificati selezionando `aws configure --profile PROFILE_NAME ` il profilo da configurare.
È possibile specificare campi aggiuntivi`metadata_service_timeout`, ad esempio e`metadata_service_num_attempts`. Questi non sono configurabili con la CLI: è necessario modificare il file manualmente se si desidera utilizzarli. Per ulteriori informazioni sul file di configurazione e sui campi disponibili, vedere [Configurazione di AWS Command Line Interface nella Guida per l'](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)utente. AWS Command Line Interface
### Caricare le credenziali
Dopo aver impostato le credenziali temporanee, l'SDK le carica utilizzando la catena di provider di credenziali predefinita.
A tale scopo, create un'istanza di un Servizio AWS client senza fornire esplicitamente le credenziali al builder, come segue.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
## Specificate un fornitore di credenziali o una catena di fornitori
Puoi specificare un provider delle credenziali diverso dalla catena di provider delle credenziali *predefinita* utilizzando il generatore client.
Fornisci un'istanza di un provider di credenziali o di una catena di provider a un client builder che accetta un'interfaccia [AWSCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html) come input. Nell'esempio seguente viene mostrato come utilizzare specificatamente le credenziali *ambiente*.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new EnvironmentVariableCredentialsProvider())
.build();
```
[Per l'elenco completo dei provider di credenziali e delle catene di provider AWS SDK per Java forniti, consulta **All Known Implementation** Classes in Provider. AWSCredentials](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html)
**Nota**
È possibile utilizzare questa tecnica per fornire provider di credenziali o catene di provider create utilizzando il proprio provider di credenziali che implementa l'`AWSCredentialsProvider`interfaccia o sottoclassando la classe. [AWSCredentialsProviderChain](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProviderChain.html)
## Specificate esplicitamente le credenziali temporanee
Se la catena di credenziali predefinita o un provider o una catena di fornitori specifici o personalizzati non funzionano per il codice, puoi impostare le credenziali fornite in modo esplicito. Se hai recuperato credenziali temporanee utilizzando AWS STS, usa questo metodo per specificare le credenziali di accesso. AWS
1. Crea un'istanza della [BasicSessionCredentials](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/BasicSessionCredentials.html)classe e forniscile la chiave di AWS accesso, la chiave AWS segreta e il token di AWS sessione che l'SDK utilizzerà per la connessione.
1. Crea un [AWSStaticCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSStaticCredentialsProvider.html)con l'oggetto. `AWSCredentials`
1. Configurare il generatore client con `AWSStaticCredentialsProvider` e creare il client.
Di seguito è riportato un esempio di :
```
BasicSessionCredentials awsCreds = new BasicSessionCredentials("access_key_id", "secret_key_id", "session_token");
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(awsCreds))
.build();
```
## Ulteriori informazioni
+ [Iscriviti AWS e crea un utente IAM](signup-create-iam-user.md)
+ [Configura AWS le credenziali e la regione per lo sviluppo](setup-credentials.md)
+ [Utilizzo dei ruoli IAM per concedere l'accesso alle AWS risorse su Amazon EC2](java-dg-roles.md)
# Regione AWS Selezione
Le regioni consentono di accedere ai AWS servizi che risiedono fisicamente in un'area geografica specifica. Ciò può essere utile per la ridondanza e per mantenere i dati e le applicazioni in esecuzione vicino ai punti di accesso ai servizi stessi.
## Verifica della disponibilità del servizio in una regione
Per verificare se un determinato prodotto Servizio AWS è disponibile in una regione, utilizza il `isServiceSupported` metodo relativo alla regione che desideri utilizzare.
```
Region.getRegion(Regions.US_WEST_2)
.isServiceSupported(AmazonDynamoDB.ENDPOINT_PREFIX);
```
[Consultate](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html) la documentazione della classe Regions per le regioni che potete specificare e utilizzate il prefisso endpoint del servizio per eseguire le query. Il prefisso dell'endpoint di ogni servizio è definito nell'interfaccia del servizio. [Ad esempio, il prefisso dell' DynamoDB endpoint è definito nel DB. AmazonDynamo](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html)
## Scelta di una Regione
A partire dalla versione 1.4 di AWS SDK per Java, puoi specificare un nome di regione e l'SDK sceglierà automaticamente l'endpoint appropriato per te. Per scegliere tu stesso l'endpoint, vedi [Scelta di un](#region-selection-choose-endpoint) endpoint specifico.
[Per impostare in modo esplicito una regione, ti consigliamo di utilizzare l'enumerazione Regioni.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html) Si tratta di un'enumerazione di tutte le regioni disponibili pubblicamente. Per creare un client con una regione dall'enum, usa il codice seguente.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
Se la regione che stai tentando di utilizzare non è nell'`Regions`enum, puoi impostare la regione usando una *stringa* che rappresenta il nome della regione.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion("{region_api_default}")
.build();
```
**Nota**
Dopo che è stato creato con il generatore, il client è *immutabile* e la regione *non può essere modificata*. Se state lavorando con più client Regioni AWS per lo stesso servizio, dovreste creare più client, uno per regione.
## Scelta di un endpoint specifico
Ogni AWS client può essere configurato per utilizzare un *endpoint specifico* all'interno di una regione chiamando il `withEndpointConfiguration` metodo durante la creazione del client.
Ad esempio, per configurare il Amazon S3 client per l'utilizzo della regione Europa (Irlanda), utilizzare il codice seguente.
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withEndpointConfiguration(new EndpointConfiguration(
"https://s3.eu-west-1.amazonaws.com",
"eu-west-1"))
.withCredentials(CREDENTIALS_PROVIDER)
.build();
```
Vedi [Regioni ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html) per l'elenco corrente delle regioni e gli endpoint corrispondenti per tutti i AWS servizi.
## Determina automaticamente la regione dall'ambiente
**Importante**
Questa sezione si applica solo quando si utilizza un [client builder](creating-clients.md) per accedere ai AWS servizi. AWS i client creati utilizzando il costruttore del client non determineranno automaticamente la regione dall'ambiente e utilizzeranno invece la regione SDK *predefinita* (). USEast1
Quando è in esecuzione su Amazon EC2 o Lambda, potresti voler configurare i client in modo che utilizzino la stessa regione su cui è in esecuzione il codice. Questo consente di separare il codice dall'ambiente in cui è in esecuzione e facilita la distribuzione dell'applicazione in più regioni per minore latenza o ridondanza.
*È necessario utilizzare i client builder per fare in modo che l'SDK rilevi automaticamente la regione in cui è in esecuzione il codice.*
Per utilizzare la catena di credential/region provider predefinita per determinare la regione dall'ambiente, utilizzate il metodo del client builder. `defaultClient`
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
```
È lo stesso che si usa `standard` seguito da`build`.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.build();
```
Se non impostate esplicitamente una regione utilizzando `withRegion` i metodi, l'SDK consulta la catena di fornitori di regioni predefinita per cercare di determinare la regione da utilizzare.
### Catena di provider delle regioni predefinita
**Di seguito è riportato il processo di ricerca della regione:**
1. Qualsiasi regione esplicita impostata utilizzando `withRegion` o `setRegion` sul builder stesso ha la precedenza su qualsiasi altra cosa.
1. La variabile di ambiente `AWS_REGION` è selezionata. Se è impostata, questa regione viene utilizzata per configurare il client.
**Nota**
Questa variabile di ambiente è impostata dal contenitore. Lambda
1. L'SDK controlla il file di configurazione AWS condiviso (che di solito si trova in`~/.aws/config`). Se la proprietà *region* è presente, viene utilizzata dall'SDK.
+ La variabile di ambiente `AWS_CONFIG_FILE` può essere utilizzata per personalizzare il percorso del file di configurazione condiviso.
+ La variabile di `AWS_PROFILE` ambiente o la proprietà di `aws.profile` sistema possono essere utilizzate per personalizzare il profilo caricato dall'SDK.
1. L'SDK tenta di utilizzare il servizio di metadati dell' Amazon EC2 istanza per determinare la regione dell'istanza attualmente in esecuzione. Amazon EC2
1. Se a questo punto l'SDK non ha ancora trovato una regione, la creazione del client non riesce con un'eccezione.
Durante lo sviluppo di AWS applicazioni, un approccio comune consiste nell'utilizzare il *file di configurazione condiviso* (descritto in [Utilizzo della catena di provider di credenziali predefinita](credentials.md#credentials-default)) per impostare la regione per lo sviluppo locale e fare affidamento sulla catena di provider di aree predefinita per determinare la regione durante l'esecuzione sull'infrastruttura. AWS Questo semplifica notevolmente la creazione del client e mantiene l'applicazione portatile.
# Gestione delle eccezioni
Comprendere come e quando vengono AWS SDK per Java 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é eccezioni non controllate?
AWS SDK per Java Utilizza eccezioni di runtime (o non controllate) anziché eccezioni verificate per i seguenti 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.
Per ulteriori informazioni sull'uso delle eccezioni selezionate e deselezionate, consulta:
+ [Eccezioni non controllate: la controversia](http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+ [Il problema delle eccezioni controllate](http://www.artima.com/intv/handcuffs2.html)
+ [Le eccezioni verificate di Java erano un errore (ed ecco cosa vorrei fare al riguardo)](http://radio-weblogs.com/0122027/stories/2003/04/01/JavasCheckedExceptionsWereAMistake.html)
## AmazonServiceException (e sottoclassi)
[AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html)è l'eccezione più comune che riscontrerai quando usi. AWS SDK per Java Questa eccezione rappresenta una risposta di errore da parte di un Servizio AWS. Ad esempio, se si tenta di terminare un' Amazon EC2 istanza che non esiste, EC2 restituirà una risposta di errore e tutti i dettagli di tale risposta di errore verranno inclusi nella `AmazonServiceException` risposta generata. Per alcuni casi, viene generata una sottoclasse di `AmazonServiceException` per consentire agli sviluppatori di controllare tutti i dettagli di gestione dei casi di errore tramite blocchi catch.
Quando incontri un`AmazonServiceException`, sai che la tua richiesta è stata inviata correttamente 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.
`AmazonServiceException` fornisce informazioni quali:
+ Codice di stato HTTP restituito
+ Codice AWS di errore restituito
+ Messaggio di errore dettagliato dal servizio
+ AWS ID della richiesta non riuscita
`AmazonServiceException`include anche informazioni sul fatto che la richiesta non riuscita sia stata colpa del chiamante (una richiesta con valori non validi) o colpa Servizio AWS del chiamante (un errore interno del servizio).
## AmazonClientException
[AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.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 `AmazonClientException` è generalmente più grave di un `AmazonServiceException` 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 `AmazonClientException` se non è disponibile alcuna connessione di rete quando si tenta di richiamare un'operazione su uno dei client.
# Programmazione asincrona
È possibile utilizzare metodi *sincroni* o *asincroni* per richiamare le operazioni sui servizi. AWS 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. AWS SDK per Java *Fornisce due modi: *oggetti futuri* e metodi di callback.*
## Java Futures
*I metodi asincroni AWS SDK per Java restituiscono un oggetto [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html) che contiene i risultati dell'operazione asincrona in futuro.*
Chiamate il `Future` `isDone()` metodo per vedere se il servizio ha già fornito un oggetto di risposta. Quando la risposta è pronta, è possibile ottenere l'oggetto di risposta chiamando il `Future` `get()` metodo. È possibile utilizzare questo meccanismo per verificare periodicamente i risultati dell'operazione asincrona mentre l'applicazione continua a lavorare su altre cose.
Ecco un esempio di operazione asincrona che chiama una Lambda funzione, ricevendo un oggetto che può contenere un oggetto. `Future` [InvokeResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeResult.html) L'`InvokeResult`oggetto viene recuperato solo dopo is. `isDone()` `true`
```
import com.amazonaws.services.lambda.AWSLambdaAsyncClient;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
public class InvokeLambdaFunctionAsync
{
public static void main(String[] args)
{
String function_name = "HelloFunction";
String function_input = "{\"who\":\"SDK for Java\"}";
AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
InvokeRequest req = new InvokeRequest()
.withFunctionName(function_name)
.withPayload(ByteBuffer.wrap(function_input.getBytes()));
Future future_res = lambda.invokeAsync(req);
System.out.print("Waiting for future");
while (future_res.isDone() == false) {
System.out.print(".");
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
System.err.println("\nThread.sleep() was interrupted!");
System.exit(1);
}
}
try {
InvokeResult res = future_res.get();
if (res.getStatusCode() == 200) {
System.out.println("\nLambda function returned:");
ByteBuffer response_payload = res.getPayload();
System.out.println(new String(response_payload.array()));
}
else {
System.out.format("Received a non-OK response from {AWS}: %d\n",
res.getStatusCode());
}
}
catch (InterruptedException | ExecutionException e) {
System.err.println(e.getMessage());
System.exit(1);
}
System.exit(0);
}
}
```
## Chiamate asincrone
Oltre a utilizzare l'`Future`oggetto Java per monitorare lo stato delle richieste asincrone, l'SDK consente anche di implementare una classe che utilizza l'interfaccia. [AsyncHandler](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/AsyncHandler.html) `AsyncHandler`fornisce due metodi che vengono chiamati a seconda del modo in cui la richiesta è stata completata: e. `onSuccess` `onError`
Il vantaggio principale dell'approccio dell'interfaccia di callback è che vi evita di dover interrogare l'`Future`oggetto per scoprire quando la richiesta è stata completata. Al contrario, il codice può iniziare immediatamente la sua attività successiva e fare affidamento sull'SDK per chiamare il gestore al momento giusto.
```
import com.amazonaws.services.lambda.AWSLambdaAsync;
import com.amazonaws.services.lambda.AWSLambdaAsyncClientBuilder;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import com.amazonaws.handlers.AsyncHandler;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
public class InvokeLambdaFunctionCallback
{
private class AsyncLambdaHandler implements AsyncHandler
{
public void onSuccess(InvokeRequest req, InvokeResult res) {
System.out.println("\nLambda function returned:");
ByteBuffer response_payload = res.getPayload();
System.out.println(new String(response_payload.array()));
System.exit(0);
}
public void onError(Exception e) {
System.out.println(e.getMessage());
System.exit(1);
}
}
public static void main(String[] args)
{
String function_name = "HelloFunction";
String function_input = "{\"who\":\"SDK for Java\"}";
AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
InvokeRequest req = new InvokeRequest()
.withFunctionName(function_name)
.withPayload(ByteBuffer.wrap(function_input.getBytes()));
Future future_res = lambda.invokeAsync(req, new AsyncLambdaHandler());
System.out.print("Waiting for async callback");
while (!future_res.isDone() && !future_res.isCancelled()) {
// perform some other tasks...
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
System.err.println("Thread.sleep() was interrupted!");
System.exit(0);
}
System.out.print(".");
}
}
}
```
## Best practice
### Esecuzione del callback
L'implementazione di `AsyncHandler` viene eseguita all'interno del pool di thread di proprietà del client asincrono. Il codice breve ed eseguito rapidamente è il più appropriato all'interno dell'implementazione. `AsyncHandler` Il codice a esecuzione prolungata o bloccante all'interno dei metodi di gestione può causare conflitti per il pool di thread utilizzato dal client asincrono e impedire al client di eseguire le richieste. Se hai un'attività di lunga durata che deve iniziare da un callback, chiedi al callback di eseguire la sua attività in un nuovo thread o in un pool di thread gestito dall'applicazione.
### Configurazione del pool di thread
I client asincroni inclusi in AWS SDK per Java forniscono un pool di thread predefinito che dovrebbe funzionare per la maggior parte delle applicazioni. È possibile implementare un file personalizzato [ExecutorService](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ExecutorService.html)e passarlo a client AWS SDK per Java asincroni per un maggiore controllo sulla gestione dei pool di thread.
Ad esempio, è possibile fornire un'`ExecutorService`implementazione che utilizzi un'impostazione personalizzata [ThreadFactory](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ThreadFactory.html)per controllare il modo in cui vengono denominati i thread nel pool o per registrare informazioni aggiuntive sull'utilizzo dei thread.
### Accesso asincrono
La [TransferManager](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/TransferManager.html)classe dell'SDK offre supporto asincrono con cui lavorare. Amazon S3`TransferManager`gestisce caricamenti e download asincroni, fornisce report dettagliati sullo stato di avanzamento dei trasferimenti e supporta i callback in diversi eventi.
# AWS SDK per Java Registrazione delle chiamate
AWS SDK per Java È dotato di strumentazione con [Apache Commons Logging](http://commons.apache.org/proper/commons-logging/guide.html), che è un livello di astrazione che consente l'uso di uno qualsiasi dei numerosi sistemi di registrazione in fase di esecuzione.
I sistemi di registrazione supportati includono, tra gli altri, Java Logging Framework e Apache Log4j. In questo argomento viene mostrato come utilizzare Log4j. Puoi utilizzare la funzionalità di registrazione dell'SDK senza apportare modifiche al codice dell'applicazione.
Per ulteriori informazioni su [Log4j](http://logging.apache.org/log4j/2.x/), visita il [sito Web Apache](http://www.apache.org/).
**Nota**
Questo argomento si concentra su Log4j 1.x. Log4j2 non supporta direttamente Apache Commons Logging, ma fornisce un adattatore che indirizza automaticamente la registrazione delle chiamate a Log4j2 utilizzando l'interfaccia Apache Commons Logging. Per ulteriori informazioni, [consulta Commons Logging](https://logging.apache.org/log4j/2.x/log4j-jcl.html) Bridge nella documentazione di Log4j2.
## Scarica il file JAR Log4J
Per utilizzare Log4j con l'SDK, devi scaricare il JAR Log4j dal sito Web di Apache. L'SDK non include il JAR. Copia il file JAR in una posizione sul tuo classpath.
Log4j utilizza un file di configurazione, log4j.properties. File di configurazione di esempio sono mostrati di seguito. Copia questo file di configurazione in una directory sul tuo classpath. Il file JAR Log4j e il file log4j.properties non devono necessariamente trovarsi nella stessa directory.
[Il file di configurazione log4j.properties specifica proprietà come il [livello di registrazione, dove viene inviato l'](http://logging.apache.org/log4j/2.x/manual/configuration.html#Loggers)output di registrazione (ad esempio, [a un file o alla](http://logging.apache.org/log4j/2.x/manual/appenders.html) console) e il formato dell'output.](http://logging.apache.org/log4j/2.x/manual/layouts.html) Il livello di registrazione è la granularità di output generata dal logger. Log4j supporta il concetto di *gerarchie* di registrazione multiple. Il livello di registrazione è impostato in modo indipendente per ogni gerarchia. Le due gerarchie di registrazione seguenti sono disponibili in AWS SDK per Java:
+ log4j.logger.com.amazonaws
+ log4j.logger.org.apache.http.wire
## Impostazione di classpath
Sia il file JAR Log4j che il file log4j.properties devono trovarsi nel classpath. Se stai usando [Apache Ant, imposta il classpath nell'elemento del tuo file Ant](http://ant.apache.org/manual/). `path` L'esempio seguente mostra un elemento del percorso del file Ant per l' Amazon S3 [esempio](https://github.com/aws/aws-sdk-java/blob/master/src/samples/AmazonS3/build.xml) incluso nell'SDK.
```
```
Se stai utilizzando l'IDE Eclipse, puoi impostare il classpath aprendo il menu e passando a **Project (Progetto)** \$1 **Properties (Proprietà)** \$1 **Java Build Path (Percorso build Java)**.
## Errori e avvertenze specifici del servizio
Ti consigliamo di lasciare sempre la gerarchia dei logger «com.amazonaws» impostata su «WARN» per catturare eventuali messaggi importanti dalle librerie dei client. Ad esempio, se il Amazon S3 client rileva che l'applicazione non ha chiuso correttamente un'applicazione `InputStream` e che potrebbe essere in corso una perdita di risorse, il client S3 lo segnala tramite un messaggio di avviso ai log. Questo garantisce inoltre che i messaggi vengono registrati se il client presenta problemi di gestione delle richieste o delle risposte.
Il seguente file log4j.properties lo imposta su WARN, che include `rootLogger` i messaggi di avviso e di errore provenienti da tutti i logger nella gerarchia «com.amazonaws». In alternativa, puoi impostare esplicitamente il logger com.amazonaws su WARN.
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Or you can explicitly enable WARN and ERROR messages for the {AWS} Java clients
log4j.logger.com.amazonaws=WARN
```
## Registrazione del riepilogo di richieste/risposte
Ogni richiesta a un Servizio AWS genera un ID di AWS richiesta univoco, utile in caso di problemi relativi alla gestione di una richiesta. Servizio AWS AWS IDs le richieste sono accessibili a livello di codice tramite gli oggetti Exception nell'SDK per qualsiasi chiamata di servizio fallita e possono anche essere segnalate tramite il livello di registro DEBUG nel logger «com.amazonaws.request».
Il seguente file log4j.properties consente un riepilogo delle richieste e delle risposte, inclusa la richiesta. AWS IDs
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Turn on DEBUG logging in com.amazonaws.request to log
# a summary of requests/responses with {AWS} request IDs
log4j.logger.com.amazonaws.request=DEBUG
```
Di seguito è riportato un esempio di output del log.
```
2009-12-17 09:53:04,269 [main] DEBUG com.amazonaws.request - Sending
Request: POST https://rds.amazonaws.com / Parameters: (MaxRecords: 20,
Action: DescribeEngineDefaultParameters, SignatureMethod: HmacSHA256,
AWSAccessKeyId: ACCESSKEYID, Version: 2009-10-16, SignatureVersion: 2,
Engine: mysql5.1, Timestamp: 2009-12-17T17:53:04.267Z, Signature:
q963XH63Lcovl5Rr71APlzlye99rmWwT9DfuQaNznkD, ) 2009-12-17 09:53:04,464
[main] DEBUG com.amazonaws.request - Received successful response: 200, {AWS}
Request ID: 694d1242-cee0-c85e-f31f-5dab1ea18bc6 2009-12-17 09:53:04,469
[main] DEBUG com.amazonaws.request - Sending Request: POST
https://rds.amazonaws.com / Parameters: (ResetAllParameters: true, Action:
ResetDBParameterGroup, SignatureMethod: HmacSHA256, DBParameterGroupName:
java-integ-test-param-group-0000000000000, AWSAccessKeyId: ACCESSKEYID,
Version: 2009-10-16, SignatureVersion: 2, Timestamp:
2009-12-17T17:53:04.467Z, Signature:
9WcgfPwTobvLVcpyhbrdN7P7l3uH0oviYQ4yZ+TQjsQ=, )
2009-12-17 09:53:04,646 [main] DEBUG com.amazonaws.request - Received
successful response: 200, {AWS} Request ID:
694d1242-cee0-c85e-f31f-5dab1ea18bc6
```
## Registrazione in rete Verbose
In alcuni casi, può essere utile visualizzare le richieste e le risposte esatte inviate e ricevute AWS SDK per Java . Non è consigliabile abilitare questa registrazione nei sistemi di produzione perché la scrittura di richieste di grandi dimensioni (ad esempio, un file in fase di caricamento Amazon S3) o risposte può rallentare notevolmente un'applicazione. Se hai davvero bisogno di accedere a queste informazioni, puoi abilitarle temporaneamente tramite il logger Apache HttpClient 4. Abilitando il livello DEBUG sul logger `org.apache.http.wire` si abilita la registrazione di tutti i dati di richiesta e di risposta.
Il seguente file log4j.properties attiva la registrazione cablata completa in Apache HttpClient 4 e dovrebbe essere attivato solo temporaneamente perché può avere un impatto significativo sulle prestazioni dell'applicazione.
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Log all HTTP content (headers, parameters, content, etc) for
# all requests and responses. Use caution with this since it can
# be very expensive to log such verbose data!
log4j.logger.org.apache.http.wire=DEBUG
```
## Registrazione delle metriche di latenza
Se state cercando di risolvere i problemi e volete vedere metriche come il processo che richiede più tempo o se il lato server o client ha la latenza maggiore, il registratore di latenza può essere utile. Imposta il `com.amazonaws.latency` logger su DEBUG per abilitare questo logger.
**Nota**
Questo logger è disponibile solo se le metriche SDK sono abilitate. [Per ulteriori informazioni sul pacchetto di metriche SDK, consulta Enabling Metrics for. AWS SDK per Java](generating-sdk-metrics.md)
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.logger.com.amazonaws.latency=DEBUG
```
Di seguito è riportato un esempio di output del log.
```
com.amazonaws.latency - ServiceName=[{S3}], StatusCode=[200],
ServiceEndpoint=[https://list-objects-integ-test-test.s3.amazonaws.com],
RequestType=[ListObjectsV2Request], AWSRequestID=[REQUESTID], HttpClientPoolPendingCount=0,
RetryCapacityConsumed=0, HttpClientPoolAvailableCount=0, RequestCount=1,
HttpClientPoolLeasedCount=0, ResponseProcessingTime=[52.154], ClientExecuteTime=[487.041],
HttpClientSendRequestTime=[192.931], HttpRequestTime=[431.652], RequestSigningTime=[0.357],
CredentialsRequestTime=[0.011, 0.001], HttpClientReceiveResponseTime=[146.272]
```
# Configurazione del client
AWS SDK per Java Consente di modificare la configurazione predefinita del client, utile quando si desidera:
+ Connect a Internet tramite proxy
+ Modifica le impostazioni di trasporto HTTP, ad esempio il timeout della connessione e i tentativi di richiesta
+ Specificare i suggerimenti sulla dimensione del buffer del socket TCP
## Configurazione proxy
Quando si costruisce un oggetto client, è possibile passare un [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)oggetto opzionale per personalizzare la configurazione del client.
Se ti connetti a Internet tramite un server proxy, dovrai configurare le impostazioni del server proxy (host proxy, porta e nome utente/password) tramite l'oggetto. `ClientConfiguration`
## Configurazione del trasporto HTTP
È possibile configurare diverse opzioni di trasporto HTTP utilizzando l'[ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)oggetto. Di tanto in tanto vengono aggiunte nuove opzioni; per visualizzare l'elenco completo delle opzioni che è possibile recuperare o impostare, consulta l' AWS SDK per Java API Reference.
**Nota**
Ciascuno dei valori configurabili ha un valore predefinito definito da una costante. Per un elenco dei valori costanti per`ClientConfiguration`, consulta [Constant Field Values](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) nel riferimento AWS SDK per Java API.
### Numero massimo connessioni
È possibile impostare il numero massimo consentito di connessioni HTTP aperte utilizzando [ClientConfiguration. setMaxConnections](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxConnections-int-)metodo.
**Importante**
Imposta il numero massimo di connessioni per il numero di transazioni simultanee per evitare problemi e performance scarse. Per il valore massimo di connessioni predefinito, consulta [Constant Field Values](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) nel riferimento AWS SDK per Java API.
### Timeout e gestione degli errori
È possibile impostare opzioni relative ai timeout e alla gestione degli errori con le connessioni HTTP.
+ **Timeout di connessione**
Il timeout della connessione è la quantità di tempo (in millisecondi) che la connessione HTTP aspetterà per stabilire una connessione prima di rinunciare. L'impostazione predefinita è 10.000 ms.
Per impostare tu stesso questo valore, usa il [ClientConfiguration. setConnectionTimeout](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTimeout-int-)metodo.
+ **Connection Time to Live (TTL)**
Per impostazione predefinita, l'SDK tenterà di riutilizzare le connessioni HTTP il più a lungo possibile. In situazioni di errore in cui viene stabilita una connessione a un server che è stato messo fuori servizio, disporre di un TTL limitato può facilitare il ripristino dell'applicazione. Ad esempio, impostando un TTL di 15 minuti, anche se è stata stabilita una connessione a un server con problemi, sarà possibile ristabilire la connessione a un nuovo server entro 15 minuti.
[Per impostare il TTL della connessione HTTP, utilizzate il metodo .setConnectionTTL. ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTTL-long-)
+ **Numero massimo di tentativi di errore**
Il numero massimo di tentativi predefinito per gli errori recuperabili è 3. [È possibile impostare un valore diverso utilizzando il. ClientConfiguration setMaxErrorMetodo Retry](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxErrorRetry-int-).
### Indirizzo locale
[Per impostare l'indirizzo locale a cui il client HTTP si collegherà, usaClientConfiguration. setLocalAddress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setLocalAddress-java.net.InetAddress-).
## Suggerimenti sulla dimensione del buffer del socket TCP
Gli utenti esperti che desiderano ottimizzare i parametri TCP di basso livello possono inoltre impostare suggerimenti sulla dimensione del buffer TCP tramite l'oggetto. [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html) La maggior parte degli utenti non avrà mai bisogno di modificare questi valori, ma sono disponibili per utenti esperti.
Le dimensioni ottimali del buffer TCP per un'applicazione dipendono in larga misura dalla configurazione e dalle funzionalità della rete e del sistema operativo. Ad esempio, la maggior parte dei sistemi operativi moderni fornisce una logica di regolazione automatica per le dimensioni del buffer TCP. Ciò può avere un grande impatto sulle prestazioni delle connessioni TCP che vengono mantenute aperte abbastanza a lungo da consentire l'ottimizzazione automatica per ottimizzare le dimensioni del buffer.
Le grandi dimensioni del buffer (ad esempio, 2 MB) consentono al sistema operativo di bufferizzare più dati in memoria senza richiedere al server remoto di confermare la ricezione di tali informazioni, e quindi possono essere particolarmente utili quando la rete ha un'elevata latenza.
Questo è solo un *suggerimento* e il sistema operativo potrebbe non rispettarlo. Quando si utilizza questa opzione, gli utenti devono sempre verificare i limiti e le impostazioni predefinite configurati del sistema operativo. La maggior parte dei sistemi operativi ha un limite massimo di dimensione del buffer TCP configurato e non consente di superare tale limite a meno che non aumenti esplicitamente il limite massimo di dimensione del buffer TCP.
Sono disponibili molte risorse per facilitare la configurazione delle dimensioni del buffer TCP e delle impostazioni TCP specifiche del sistema operativo, tra cui:
+ [Ottimizzazione dell'host](http://fasterdata.es.net/host-tuning/)
# Policy di controllo degli accessi
AWS *le politiche di controllo degli accessi* consentono di specificare controlli di accesso dettagliati sulle risorse. AWS Una politica di controllo degli accessi consiste in una raccolta di *dichiarazioni*, che assumono la forma:
L'*account A* è autorizzato a eseguire *l'azione B* sulla *risorsa C* laddove si applica la *condizione D.*
Dove:
+ *A* è il *principale*, Account AWS ovvero la richiesta di accesso o modifica di una delle tue AWS risorse.
+ *B* è l'*azione*: il modo in cui si accede o si modifica la AWS risorsa, ad esempio l'invio di un messaggio a una Amazon SQS coda o la memorizzazione di un oggetto in un Amazon S3 bucket.
+ *C* è la *risorsa*: l' AWS entità a cui il principale desidera accedere, ad esempio una Amazon SQS coda o un oggetto in cui è memorizzato. Amazon S3
+ *D* è un *insieme di condizioni*: i vincoli opzionali che specificano quando consentire o negare l'accesso al principale per accedere alla risorsa. Sono disponibili molte condizioni espressive, alcune specifiche per ogni servizio. Ad esempio, è possibile utilizzare le condizioni relative alla data per consentire l'accesso alle risorse solo dopo o prima di un orario specifico.
## Amazon S3 Esempio
L'esempio seguente dimostra una politica che consente a chiunque di accedere alla lettura di tutti gli oggetti in un bucket, ma limita l'accesso al caricamento di oggetti in quel bucket a due Account AWS s specifici (oltre all'account del proprietario del bucket).
```
Statement allowPublicReadStatement = new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(S3Actions.GetObject)
.withResources(new S3ObjectResource(myBucketName, "*"));
Statement allowRestrictedWriteStatement = new Statement(Effect.Allow)
.withPrincipals(new Principal("123456789"), new Principal("876543210"))
.withActions(S3Actions.PutObject)
.withResources(new S3ObjectResource(myBucketName, "*"));
Policy policy = new Policy()
.withStatements(allowPublicReadStatement, allowRestrictedWriteStatement);
AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();
s3.setBucketPolicy(myBucketName, policy.toJson());
```
## Amazon SQS Esempio
Un uso comune delle policy consiste nell'autorizzare una Amazon SQS coda a ricevere messaggi da un argomento di Amazon SNS.
```
Policy policy = new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SQSActions.SendMessage)
.withConditions(ConditionFactory.newSourceArnCondition(myTopicArn)));
Map queueAttributes = new HashMap();
queueAttributes.put(QueueAttributeName.Policy.toString(), policy.toJson());
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
sqs.setQueueAttributes(new SetQueueAttributesRequest(myQueueUrl, queueAttributes));
```
## Esempio di Amazon SNS
Alcuni servizi offrono condizioni aggiuntive che possono essere utilizzate nelle politiche. Amazon SNS fornisce le condizioni per consentire o negare le sottoscrizioni agli argomenti SNS in base al protocollo (ad esempio e-mail, HTTP, HTTPS Amazon SQS) e all'endpoint (ad es. indirizzo e-mail, URL, Amazon SQS ARN) della richiesta di sottoscrizione a un argomento.
```
Condition endpointCondition =
SNSConditionFactory.newEndpointCondition("*@mycompany.com");
Policy policy = new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SNSActions.Subscribe)
.withConditions(endpointCondition));
AmazonSNS sns = AmazonSNSClientBuilder.defaultClient();
sns.setTopicAttributes(
new SetTopicAttributesRequest(myTopicArn, "Policy", policy.toJson()));
```
# 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.
# Abilitazione delle metriche per AWS SDK per Java
AWS SDK per Java Possono generare metriche per la visualizzazione e il monitoraggio con [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) che misurano:
+ le prestazioni della tua applicazione durante l'accesso AWS
+ le prestazioni del tuo JVMs quando viene utilizzato con AWS
+ dettagli dell'ambiente di runtime come memoria heap, numero di thread e descrittori di file aperti
## Come abilitare Java SDK Metric Generation
È necessario aggiungere la seguente dipendenza Maven per abilitare l'SDK a cui inviare le metriche. CloudWatch
```
com.amazonaws
aws-java-sdk-bom
1.12.490*
pom
import
com.amazonaws
aws-java-sdk-cloudwatchmetrics
provided
```
\$1 [Sostituisci il numero di versione con l'ultima versione dell'SDK disponibile su Maven Central.](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom)
AWS SDK per Java *le metriche sono disabilitate per impostazione predefinita.* Per abilitarlo per il tuo ambiente di sviluppo locale, includi una proprietà di sistema che punti al file delle credenziali AWS di sicurezza all'avvio della JVM. Esempio:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties
```
È necessario specificare il percorso del file di credenziali in modo che l'SDK possa caricare i punti dati raccolti per un'analisi successiva. CloudWatch
**Nota**
Se accedi AWS da un' Amazon EC2 istanza utilizzando il servizio di metadati dell' Amazon EC2 istanza, non è necessario specificare un file di credenziali. In questo caso, devi solo specificare:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics
```
*Tutte le metriche acquisite da si AWS SDK per Java trovano nello spazio dei nomi **AWSSDK/Java** e vengono caricate CloudWatch nella regione predefinita (us-east-1).* Per modificare la regione, specificala utilizzando l'attributo nella proprietà di sistema. `cloudwatchRegion` Ad esempio, per impostare la CloudWatch regione su *us-east-1*, usa:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,cloudwatchRegion={region_api_default}
```
Una volta abilitata la funzionalità, ogni volta che viene inviata una richiesta di servizio, i dati metrici verranno generati AWS SDK per Java, messi in coda per il riepilogo statistico e caricati in modo asincrono circa una volta al minuto. AWS CloudWatch Una volta caricate le metriche, puoi visualizzarle utilizzando [Console di gestione AWS](https://console.aws.amazon.com/console/home)e impostare allarmi su potenziali problemi come perdita di memoria, perdita del descrittore di file e così via.
## Tipi di metriche disponibili
Il set di metriche predefinito è suddiviso in tre categorie principali:
AWS Richiedi metriche
+ Copre aree quali la latenza della richiesta/risposta HTTP, il numero di richieste, le eccezioni e i nuovi tentativi.
![\[RequestMetric 131111\]](http://docs.aws.amazon.com/it_it/sdk-for-java/v1/developer-guide/images/RequestMetric-131111.png)
Servizio AWS Metriche
+ Includi dati Servizio AWS specifici, come la velocità effettiva e il numero di byte per i caricamenti e i download di S3.
![\[ServiceMetric 131111\]](http://docs.aws.amazon.com/it_it/sdk-for-java/v1/developer-guide/images/ServiceMetric-131111.png)
Metriche della macchina
+ Copre l'ambiente di runtime, inclusi la memoria heap, il numero di thread e i descrittori di file aperti.
![\[MachineMetric 131111\]](http://docs.aws.amazon.com/it_it/sdk-for-java/v1/developer-guide/images/MachineMetric-131111.png)
Se desideri escludere Machine Metrics, aggiungi `excludeMachineMetrics` alla proprietà di sistema:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,excludeMachineMetrics
```
## Ulteriori informazioni
+ Consulta il [riepilogo del pacchetto amazonaws/metrics](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/package-summary.html) per un elenco completo dei tipi di metriche principali predefiniti.
+ [Scopri come utilizzare il file in Esempi utilizzando il CloudWatch . AWS SDK per Java CloudWatch AWS SDK per Java](examples-cloudwatch.md)
+ Scopri di più sull'ottimizzazione delle prestazioni nel post del blog [Tuning the AWS SDK per Java to Improve Resiliency.](https://aws.amazon.com/blogs/developer/tuning-the-aws-sdk-for-java-to-improve-resiliency)