Le AWS SDK pour Java 1.x a été atteint end-of-support le 31 décembre 2025. Nous vous recommandons de migrer vers le pour continuer [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html)à bénéficier des nouvelles fonctionnalités, des améliorations de disponibilité et des mises à jour de sécurité.
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# À l'aide du AWS SDK pour Java
Cette section fournit des informations générales importantes sur la programmation avec le AWS SDK pour Java qui s'appliquent à tous les services que vous pouvez utiliser avec le SDK.
Pour obtenir des informations et des exemples de programmation spécifiques au service (pour Amazon EC2, Amazon S3, Amazon SWF, etc.), voir Exemples de [AWS SDK pour Java code](prog-services.md).
**Topics**
+ [Meilleures pratiques en matière AWS de développement avec le AWS SDK pour Java](best-practices.md)
+ [Création de clients de service](creating-clients.md)
+ [Fournir des informations d'identification temporaires](credentials.md)
+ [Région AWS Sélection](java-dg-region-selection.md)
+ [Gestion des exceptions](java-dg-exceptions.md)
+ [Programmation asynchrone](basics-async.md)
+ [Enregistrement AWS SDK pour Java des appels](java-dg-logging.md)
+ [Configuration de client](section-client-configuration.md)
+ [Stratégies de contrôle d'accès](java-dg-access-control.md)
+ [Définissez le TTL de la JVM pour les recherches de noms DNS](jvm-ttl-dns.md)
+ [Activation des métriques pour AWS SDK pour Java](generating-sdk-metrics.md)
# Meilleures pratiques en matière AWS de développement avec le AWS SDK pour Java
Les meilleures pratiques suivantes peuvent vous aider à éviter les problèmes lorsque vous développez des AWS applications avec le AWS SDK pour Java. Nous avons organisé les bonnes pratiques par service.
## S3
### Éviter ResetExceptions
Lorsque vous chargez des objets à Amazon S3 l'aide de flux (via un `AmazonS3` client ou`TransferManager`), vous pouvez rencontrer des problèmes de connectivité réseau ou de délai d'expiration. Par défaut, les AWS SDK pour Java tentatives de nouvelle tentative de transfert ont échoué en marquant le flux d'entrée avant le début du transfert, puis en le réinitialisant avant de réessayer.
Si le flux ne prend pas en charge le marquage et la réinitialisation, le SDK lance un message en [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)cas d'échec transitoire et les nouvelles tentatives sont activées.
**Bonne pratique**
Nous vous recommandons d'utiliser des flux qui prennent en charge les opérations de marquage et de réinitialisation.
Le moyen le plus fiable d'éviter un [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)est de fournir des données à l'aide d'un [fichier](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) ou [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html), qu'ils AWS SDK pour Java peuvent gérer sans être limités par des limites de marquage et de réinitialisation.
Si le stream n'est pas un [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html)mais qu'il prend en charge le marquage et la réinitialisation, vous pouvez définir la limite de points en utilisant la `setReadLimit` méthode de [RequestClientOptions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/RequestClientOptions.html). Sa valeur par défaut est 128 Ko. La définition de la valeur limite de lecture à *un octet de plus que la taille du flux* évitera de manière fiable un [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html).
Par exemple, si la taille maximale attendue d'un flux est 100 000 octets, définissez la limite de lecture sur 100 001 (100 000 \$1 1) octets. Le marquage et la réinitialisation fonctionneront toujours pour 100 000 octets ou moins. Ayez à l'esprit que cela peut entraîner le fait que certains flux mettent en mémoire tampon le nombre d'octets en mémoire.
# Création de clients de service
Pour envoyer des demandes à Amazon Web Services, vous devez d'abord créer un objet client de service. La méthode recommandée consiste à utiliser le générateur client de service.
Chacun Service AWS possède une interface de service avec des méthodes pour chaque action dans l'API de service. Par exemple, l'interface de service de DynamoDB est nommée. [AmazonDynamoDBClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClient.html) Chaque interface de service possède un générateur client correspondant que vous pouvez utiliser pour construire une implémentation de l'interface de service. La classe de création de clients pour DynamoDB s'appelle [AmazonDynamoDBClientBuilder](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClientBuilder.html).
## Obtention d'un générateur client
Pour obtenir une instance du générateur client, utilisez la méthode de fabrique.statique `standard`, comme illustré dans l'exemple suivant.
```
AmazonDynamoDBClientBuilder builder = AmazonDynamoDBClientBuilder.standard();
```
Une fois que vous disposez d'un générateur, vous pouvez personnaliser les propriétés du client à l'aide de nombreuses méthodes setter Fluent dans l'API du générateur. Par exemple, vous pouvez définir une région personnalisée et un fournisseur d'informations d'identification personnalisé, comme suit.
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
**Note**
Les méthodes `withXXX` Fluent renvoient l'objet `builder` pour vous permettre de chaîner les appels de méthode pour plus de commodité et un code plus lisible. Une fois que vous avez configuré les propriétés souhaitées, vous pouvez appeler la méthode `build` pour créer le client. Une fois qu'un client a été créé, il est immuable et tous les appels à `setRegion` ou `setEndpoint` échoueront.
Un générateur peut créer plusieurs clients avec la même configuration. Lorsque vous écrivez votre application, gardez à l'esprit que le générateur est mutable et n'est pas thread-safe.
Le code suivant utilise le générateur en tant que fabrique pour les instances 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();
}
}
```
[Le générateur expose également des setters fluides pour [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)et [RequestMetricCollector](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/RequestMetricCollector.html), ainsi qu'une liste personnalisée de RequestHandler 2.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/RequestHandler2.html)
Voici un exemple complet qui remplace toutes les propriétés configurables.
```
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();
```
## Création de clients asynchrones
AWS SDK pour Java Il possède des clients asynchrones (ou asynchrones) pour chaque service (sauf pour Amazon S3) et un générateur de clients asynchrones correspondant pour chaque service.
### Pour créer un client DynamoDB asynchrone avec la valeur par défaut ExecutorService
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
Outre les options de configuration prises en charge par le générateur de clients synchrones (ou de synchronisation), le client asynchrone vous permet de définir une personnalisation [ExecutorFactory](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/client/builder/ExecutorFactory.html)pour modifier `ExecutorService` celle utilisée par le client asynchrone. `ExecutorFactory`est une interface fonctionnelle, elle interagit donc avec les expressions lambda de Java 8 et les références de méthodes.
### Pour créer un client asynchrone avec un exécuteur personnalisé
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withExecutorFactory(() -> Executors.newFixedThreadPool(10))
.build();
```
## En utilisant DefaultClient
Les générateurs client synchrones et asynchrones ont une autre méthode nommée `defaultClient`. Cette méthode crée un client de service avec la configuration par défaut, en utilisant la chaîne de fournisseurs par défaut pour charger les informations d'identification et le Région AWS. Si les informations d'identification ou la région ne peuvent pas être déterminées à partir de l'environnement dans lequel l'application s'exécute, l'appel à `defaultClient` échoue. Voir [Utilisation des AWS informations d'identification](credentials.md) et [Région AWS sélection](java-dg-region-selection.md) pour plus d'informations sur la manière dont les informations d'identification et la région sont déterminées.
### Pour créer un service client par défaut
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
```
## Cycle de vie des clients
Les clients de service du kit SDK sont thread-safe, et pour des performances optimales, vous devrez les traiter comme des objets à longue durée de vie. Chaque client possède sa propre ressource de groupe de connexion. Arrêtez explicitement les clients lorsque vous n'en avez plus besoin pour éviter les fuites de ressources.
Pour arrêter explicitement un client, appelez la méthode `shutdown`. Une fois la méthode `shutdown` appelée, toutes les ressources client sont libérées et le client devient inutilisable.
### Pour arrêter un client
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.shutdown();
// Client is now unusable
```
# Fournissez des informations d'identification temporaires au AWS SDK pour Java
Pour faire des demandes à Amazon Web Services, vous devez fournir des informations d'identification AWS temporaires AWS SDK pour Java à utiliser lorsqu'il appelle les services. Vous pouvez effectuer cette opération de différentes manières :
+ Utilisez la chaîne de fournisseur d'informations d'identification par défaut *(recommandé)*.
+ Utilisez un fournisseur ou une chaîne de fournisseur d'informations d'identification spécifique (ou créez le vôtre).
+ Fournissez vous-même les informations d'identification temporaires sous forme de code.
## Utilisation de la chaîne de fournisseur d'informations d'identification par défaut
Lorsque vous initialisez un nouveau client de service sans fournir d'arguments, il AWS SDK pour Java tente de trouver des informations d'identification temporaires en utilisant la *chaîne de fournisseurs d'informations d'identification par défaut* implémentée par la classe [AWSCredentialsProviderChainDefault](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/DefaultAWSCredentialsProviderChain.html). La chaîne de fournisseur d'informations d'identification par défaut recherche les informations d'identification dans l'ordre suivant :
1. **Variables d'environnement** -`AWS_ACCESS_KEY_ID`, `AWS_SECRET_KEY` ou`AWS_SECRET_ACCESS_KEY`, et`AWS_SESSION_TOKEN`. AWS SDK pour Java Utilise la [EnvironmentVariableCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EnvironmentVariableCredentialsProvider.html)classe pour charger ces informations d'identification.
1. **Propriétés du système Java** -`aws.accessKeyId`, `aws.secretKey` (mais pas`aws.secretAccessKey`), et`aws.sessionToken`. AWS SDK pour Java Utilise le [SystemPropertiesCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/SystemPropertiesCredentialsProvider.html)pour charger ces informations d'identification.
1. **Informations d'identification du jeton d'identité web** à partir de l'environnement ou du conteneur.
1. **Le fichier de profils d'identification par défaut**, généralement situé dans `~/.aws/credentials` (l'emplacement peut varier selon la plate-forme), et partagé par de nombreux AWS SDKs et par le AWS CLI. AWS SDK pour Java Utilise le [ProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/profile/ProfileCredentialsProvider.html)pour charger ces informations d'identification.
Vous pouvez créer un fichier d'informations d'identification à l'aide de la `aws configure` commande fournie par le AWS CLI, ou vous pouvez le créer en modifiant le fichier à l'aide d'un éditeur de texte. Pour plus d'informations sur le format de fichier d'informations d'identification, voir Format de [fichier AWS d'informations d'identification](#credentials-file-format).
1. **Informations d'identification du conteneur Amazon ECS** : chargées depuis Amazon ECS si la variable d'environnement `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` est définie. AWS SDK pour Java Utilise le [ContainerCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/ContainerCredentialsProvider.html)pour charger ces informations d'identification. Vous pouvez spécifier l'adresse IP de cette valeur.
1. **Informations d'identification du profil d'instance** : utilisées sur les instances EC2 et fournies via le service de Amazon EC2 métadonnées. AWS SDK pour Java Utilise le [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)pour charger ces informations d'identification. Vous pouvez spécifier l'adresse IP de cette valeur.
**Note**
Les informations d'identification de profil d'instance sont utilisées uniquement si la variable d'environnement `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` n'est pas définie. Pour plus d’informations, consultez [EC2ContainerCredentialsProviderWrapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EC2ContainerCredentialsProviderWrapper.html).
### Définissez des informations d'identification temporaires
Pour pouvoir utiliser des informations d'identification AWS temporaires, elles doivent être définies dans *au moins l'un* des emplacements précédents. Pour plus d'informations sur la définition des informations d'identification, consultez les rubriques suivantes :
+ Pour spécifier les informations d'identification dans l'*environnement* ou dans le *fichier de profils d'identification* par défaut, consultez[Configurer les informations d'identification temporaires](setup-credentials.md#setup-credentials-setting).
+ Pour définir les *propriétés système* Java, consultez le didacticiel [System Properties](http://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) sur le site web *Java Tutorials* officiel.
+ Pour configurer et utiliser les *informations d'identification du profil d'instance* avec vos instances EC2, consultez la section [Utilisation des rôles IAM pour accorder l'accès aux AWS ressources sur](java-dg-roles.md). Amazon EC2
### Définir un autre profil d'identification
AWS SDK pour Java *Utilise le profil par défaut, mais il existe des moyens de personnaliser le profil qui provient du fichier d'informations d'identification.*
Vous pouvez utiliser la variable d'environnement AWS Profile pour modifier le profil chargé par le SDK.
Par exemple, sous Linux, macOS ou Unix, vous devez exécuter la commande suivante pour remplacer le profil par *MyProfile*.
```
export AWS_PROFILE="myProfile"
```
Sous Windows, utilisez la commande suivante.
```
set AWS_PROFILE="myProfile"
```
La définition de la variable d'`AWS_PROFILE`environnement affecte le chargement des informations d'identification pour tous les outils officiellement pris en charge AWS SDKs (y compris le AWS CLI et le AWS Tools for Windows PowerShell). Pour modifier uniquement le profil d'une application Java, vous pouvez utiliser la propriété système à la `aws.profile` place.
**Note**
La variable d'environnement est prioritaire sur la propriété système.
### Définir un autre emplacement pour le fichier d'informations d'identification
AWS SDK pour Java Charge automatiquement les informations d'identification AWS temporaires à partir de l'emplacement du fichier d'informations d'identification par défaut. Cependant, vous pouvez également spécifier l'emplacement en définissant la variable d'environnement `AWS_CREDENTIAL_PROFILES_FILE` avec le chemin d'accès complet au fichier d'informations d'identification.
Vous pouvez utiliser cette fonctionnalité pour modifier temporairement l'emplacement où AWS SDK pour Java recherche votre fichier d'informations d'identification (par exemple, en définissant cette variable avec la ligne de commande). Vous pouvez également définir la variable d'environnement dans votre environnement utilisateur ou système pour modifier l'emplacement pour l'utilisateur ou l'ensemble du système.
#### Pour remplacer l'emplacement du fichier d'informations d'identification par défaut
+ Définissez la variable d'`AWS_CREDENTIAL_PROFILES_FILE`environnement sur l'emplacement de votre fichier AWS d'informations d'identification.
+ Sous Linux, macOS ou Unix, utilisez :
```
export AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
+ Sous Windows, utilisez :
```
set AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
### `Credentials`format de fichier
En suivant les [instructions de la section Configuration de base](signup-create-iam-user.md#setup-temp-creds) de ce guide, votre fichier d'informations d'identification doit avoir le format de base suivant.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
[profile2]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
Le nom de profil est spécifié entre crochets (par exemple, `[default]`), suivi par les champs configurables de ce profil sous la forme de paires clé-valeur. Vous pouvez avoir plusieurs profils dans votre `credentials` fichier, qui peuvent être ajoutés ou modifiés en `aws configure --profile PROFILE_NAME ` sélectionnant le profil à configurer.
Vous pouvez spécifier des champs supplémentaires, tels que`metadata_service_timeout`, et`metadata_service_num_attempts`. Ils ne sont pas configurables avec la CLI : vous devez modifier le fichier manuellement si vous souhaitez les utiliser. Pour plus d'informations sur le fichier de configuration et les champs disponibles, consultez [la section Configuration du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) dans le guide de AWS Command Line Interface l'utilisateur.
### Charger les identifiants
Une fois que vous avez défini des informations d'identification temporaires, le SDK les charge en utilisant la chaîne de fournisseurs d'informations d'identification par défaut.
Pour ce faire, vous instanciez un Service AWS client sans fournir explicitement d'informations d'identification au générateur, comme suit.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
## Spécifiez un fournisseur d'informations d'identification ou une chaîne de fournisseurs
Vous pouvez spécifier un fournisseur d'informations d'identification autre que la chaîne de fournisseur d'informations d'identification *par défaut* à l'aide du générateur client.
Vous fournissez une instance d'un fournisseur d'informations d'identification ou d'une chaîne de fournisseurs à un générateur de clients qui prend une interface [AWSCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html) en entrée. L'exemple suivant montre comment utiliser des informations d'identification d'*environnement*.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new EnvironmentVariableCredentialsProvider())
.build();
```
[Pour la liste complète des fournisseurs d'informations d'identification et des chaînes de fournisseurs AWS SDK pour Java fournis, voir **Toutes les classes d'implémentation connues** dans AWSCredentials Provider.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html)
**Note**
Vous pouvez utiliser cette technique pour fournir des fournisseurs d'informations d'identification ou des chaînes de fournisseurs que vous créez en utilisant votre propre fournisseur d'informations d'identification qui implémente l'`AWSCredentialsProvider`interface, ou en sous-classant la classe. [AWSCredentialsProviderChain](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProviderChain.html)
## Spécifiez explicitement les informations d'identification temporaires
Si la chaîne d'informations d'identification par défaut, ou un fournisseur ou une chaîne de fournisseur spécifique ou personnalisé ne fonctionne pas pour votre code, vous pouvez définir des informations d'identification que vous spécifiez explicitement. Si vous avez récupéré des informations d'identification temporaires à l'aide de AWS STS, utilisez cette méthode pour spécifier les informations d'identification pour AWS l'accès.
1. Instanciez la [BasicSessionCredentials](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/BasicSessionCredentials.html)classe et fournissez-lui la clé d' AWS accès, la clé AWS secrète et le jeton de AWS session que le SDK utilisera pour la connexion.
1. Créez un [AWSStaticCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSStaticCredentialsProvider.html)avec l'`AWSCredentials`objet.
1. Configurez le générateur client avec l'interface `AWSStaticCredentialsProvider` et générez le client.
Voici un exemple.
```
BasicSessionCredentials awsCreds = new BasicSessionCredentials("access_key_id", "secret_key_id", "session_token");
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(awsCreds))
.build();
```
## Plus d'informations
+ [Inscrivez-vous AWS et créez un utilisateur IAM](signup-create-iam-user.md)
+ [Configurer les AWS informations d'identification et la région pour le développement](setup-credentials.md)
+ [Utilisation des rôles IAM pour accorder l'accès aux AWS ressources sur Amazon EC2](java-dg-roles.md)
# Région AWS Sélection
Les régions vous permettent d'accéder à AWS des services qui résident physiquement dans une zone géographique spécifique. Cela peut être utile pour la redondance et pour maintenir vos données et vos applications en cours d'exécution à proximité de l'endroit où vous-même et vos utilisateurs y accédez.
## Vérification de la disponibilité du service dans une région
Pour savoir si un produit spécifique Service AWS est disponible dans une région, utilisez la `isServiceSupported` méthode de la région que vous souhaitez utiliser.
```
Region.getRegion(Regions.US_WEST_2)
.isServiceSupported(AmazonDynamoDB.ENDPOINT_PREFIX);
```
Consultez la documentation sur la classe [Regions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html) pour les régions que vous pouvez spécifier, et utilisez le préfixe de point de terminaison du service à interroger. Chaque préfixe de point de terminaison du service est défini dans l'interface du service. Par exemple, le préfixe du DynamoDB point de terminaison est défini dans la [AmazonDynamobase de données.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html)
## Choisir une région
À partir de la version 1.4 du AWS SDK pour Java, vous pouvez spécifier un nom de région et le SDK choisira automatiquement un point de terminaison approprié pour vous. Pour choisir le point de terminaison vous-même, consultez [Choix d'un point de terminaison spécifique](#region-selection-choose-endpoint).
Pour définir explicitement une région, nous vous recommandons d'utiliser l'énumération [Regions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html). Il s'agit d'une énumération de toutes les régions disponibles publiquement. Pour créer un client avec une région à partir de l'énumération, utilisez le code suivant.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
Si la région que vous essayez d'utiliser n'est pas dans l'énumération `Regions`, vous pouvez définir la région à l'aide d'une *chaîne* représentant le nom de la région.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion("{region_api_default}")
.build();
```
**Note**
Une fois que vous avez créé un client avec le générateur, il est *immuable* et la région *ne peut pas être modifiée*. Si vous travaillez avec plusieurs clients Régions AWS pour le même service, vous devez créer plusieurs clients, un par région.
## Choix d'un point de terminaison spécifique
Chaque AWS client peut être configuré pour utiliser un point de *terminaison spécifique* dans une région en appelant la `withEndpointConfiguration` méthode lors de la création du client.
Par exemple, pour configurer le Amazon S3 client afin qu'il utilise la région Europe (Irlande), utilisez le code suivant.
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withEndpointConfiguration(new EndpointConfiguration(
"https://s3.eu-west-1.amazonaws.com",
"eu-west-1"))
.withCredentials(CREDENTIALS_PROVIDER)
.build();
```
Voir [Régions et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html) pour la liste actuelle des régions et leurs points de terminaison correspondants pour tous les AWS services.
## Déterminer automatiquement la région à partir de l'environnement
**Important**
Cette section s'applique uniquement lors de l'utilisation d'un [générateur de clients](creating-clients.md) pour accéder aux AWS services. AWS les clients créés à l'aide du constructeur client ne détermineront pas automatiquement la région à partir de l'environnement et utiliseront à la place la région du SDK *par défaut* ()USEast1.
Lorsque vous exécutez Lambda Amazon EC2 ou Lambda, vous souhaiterez peut-être configurer les clients pour qu'ils utilisent la même région que celle sur laquelle votre code s'exécute. Votre code est ainsi dissocié de l'environnement d'exécution et le déploiement de votre application sur plusieurs régions dans le but de réduire la latence ou la redondance s'en trouve simplifié.
*Vous devez utiliser les générateurs clients pour que le kit SDK détecte automatiquement la région dans laquelle votre code s'exécute.*
Pour utiliser la chaîne de credential/region fournisseurs par défaut afin de déterminer la région à partir de l'environnement, utilisez la `defaultClient` méthode du générateur de clients.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
```
Cette solution est identique à l'utilisation de `standard` suivi par `build`.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.build();
```
Si vous ne définissez pas explicitement une région à l'aide des méthodes `withRegion`, le kit SDK consulte la chaîne du fournisseur de région par défaut afin d'essayer de déterminer la région à utiliser.
### Chaîne du fournisseur de région par défaut
**Le processus de recherche d'une région est le suivant :**
1. Toute région explicite définie en utilisant `withRegion` ou `setRegion` sur le générateur lui-même prévaut sur toute autre région.
1. La variable d'environnement `AWS_REGION` est contrôlée. Si elle est définie, cette région est utilisée pour configurer le client.
**Note**
Cette variable d'environnement est définie par le Lambda conteneur.
1. Le SDK vérifie le fichier de configuration AWS partagé (généralement situé à l'adresse`~/.aws/config`). Si la propriété *region* est présente, le kit SDK l'utilise.
+ La variable d'environnement `AWS_CONFIG_FILE` peut être utilisée pour personnaliser l'emplacement du fichier de configuration partagé.
+ La variable d'`AWS_PROFILE`environnement ou la propriété `aws.profile` système peuvent être utilisées pour personnaliser le profil chargé par le SDK.
1. Le SDK tente d'utiliser le service de métadonnées d' Amazon EC2 instance pour déterminer la région de l' Amazon EC2 instance en cours d'exécution.
1. Si le kit SDK n'a toujours pas trouvé de région par ce biais, la création du client échoue et une exception est levée.
Lors du développement d' AWS applications, une approche courante consiste à utiliser le *fichier de configuration partagé* (décrit dans [Utilisation de la chaîne de fournisseurs d'informations d'identification par défaut](credentials.md#credentials-default)) pour définir la région pour le développement local, et à s'appuyer sur la chaîne de fournisseurs de régions par défaut pour déterminer la région lors de l'exécution sur une AWS infrastructure. La création du client s'en trouve ainsi grandement simplifiée et votre application demeure portable.
# Gestion des exceptions
Il est important de comprendre comment et quand AWS SDK pour Java les exceptions sont générées pour créer des applications de haute qualité à l'aide du SDK. Les sections suivantes décrivent les différents cas d'exceptions levées par le kit SDK et la manière de les gérer de manière appropriée.
## Pourquoi des exceptions non contrôlées ?
AWS SDK pour Java Utilise des exceptions d'exécution (ou non vérifiées) au lieu d'exceptions vérifiées pour les raisons suivantes :
+ Permettre aux développeurs un contrôle extrêmement précis des erreurs qu'ils veulent gérer sans les forcer à gérer les cas exceptionnels par lesquels ils ne sont pas concernés (rendant alors leur code excessivement détaillé)
+ Pour éviter les problèmes d'évolutivité inhérents aux exceptions contrôlées dans les grandes applications
En général, les exceptions contrôlées fonctionnent bien à petite échelle, mais peuvent devenir problématiques au fur et à mesure que les applications se développent et deviennent plus complexes.
Pour plus d'informations sur l'utilisation des exceptions contrôlées et des exceptions non contrôlées, consultez :
+ [Les exceptions incontrôlées : la controverse](http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+ [Problème des exceptions contrôlées](http://www.artima.com/intv/handcuffs2.html)
+ [Les exceptions contrôlées de Java étaient une erreur (et voici ce que je voudrais faire à ce sujet)](http://radio-weblogs.com/0122027/stories/2003/04/01/JavasCheckedExceptionsWereAMistake.html)
## AmazonServiceException (et sous-classes)
[AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html)est l'exception la plus courante que vous rencontrerez lors de l'utilisation du AWS SDK pour Java. Cette exception représente une réponse d'erreur provenant d'un Service AWS. Par exemple, si vous essayez de mettre fin à une Amazon EC2 instance qui n'existe pas, EC2 renverra une réponse d'erreur et tous les détails de cette réponse d'erreur seront inclus dans le `AmazonServiceException` message envoyé. Dans certains cas, une sous-classe d'`AmazonServiceException` est levée afin de permettre aux développeurs un contrôle très précis de la gestion des cas d'erreur par le biais de blocs d'interception (catch).
Lorsque vous rencontrez un`AmazonServiceException`, vous savez que votre demande a été envoyée avec succès au Service AWS mais n'a pas pu être traitée avec succès. Cela peut être dû à une erreur des paramètres de la demande ou à un problème côté service.
`AmazonServiceException` vous fournit des informations telles que :
+ Code d'état HTTP retourné
+ Code AWS d'erreur renvoyé
+ Message d'erreur détaillé du service
+ AWS ID de demande pour la demande qui a échoué
`AmazonServiceException`inclut également des informations indiquant si l'échec de la demande est la faute de l'appelant (demande avec des valeurs illégales) ou la faute Service AWS de l'appelant (erreur de service interne).
## AmazonClientException
[AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html)indique qu'un problème s'est produit dans le code client Java, soit lors de la tentative d'envoi d'une demande, AWS soit lors de la tentative d'analyse d'une réponse de AWS. Un `AmazonClientException` est généralement plus grave qu'un `AmazonServiceException` et indique un problème majeur qui empêche le client de faire des appels de service aux AWS services. Par exemple, il AWS SDK pour Java lance une alerte `AmazonClientException` si aucune connexion réseau n'est disponible lorsque vous essayez d'appeler une opération sur l'un des clients.
# Programmation asynchrone
Vous pouvez utiliser des méthodes *synchrones* ou *asynchrones* pour appeler des opérations sur des services. AWS Les méthodes synchrones bloquent l'exécution du thread jusqu'à ce que le client reçoive une réponse du service. Les méthodes asynchrones renvoient immédiatement, en rendant le contrôle au thread appelant sans attendre de réponse.
Dans la mesure où une méthode asynchrone renvoie avant qu'une réponse ne soit disponible, vous avez besoin d'une solution pour obtenir la réponse quand elle est prête. AWS SDK pour Java Il propose deux méthodes : les *objets futurs* et les *méthodes de rappel*.
## Objets Future Java
*Les méthodes asynchrones AWS SDK pour Java renvoient un objet [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html) contenant les résultats de l'opération asynchrone à venir.*
Appelez la méthode `Future` `isDone()` pour voir si le service a déjà fourni un objet de réponse. Lorsque la réponse est prête, vous pouvez obtenir l'objet de la réponse en appelant la méthode `Future``get()`. Vous pouvez utiliser ce mécanisme pour interroger régulièrement les résultats de l'opération asynchrone, tandis que votre application continue à travailler sur d'autres éléments.
Voici un exemple d'opération asynchrone qui appelle une Lambda fonction et reçoit un objet `Future` pouvant contenir un [InvokeResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeResult.html)objet. L'objet `InvokeResult` est récupéré uniquement après qu'`isDone()` a la valeur `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);
}
}
```
## Rappels asynchrones
Outre l'utilisation de l'`Future`objet Java pour surveiller l'état des demandes asynchrones, le SDK vous permet également d'implémenter une classe qui utilise l'interface. [AsyncHandler](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/AsyncHandler.html) `AsyncHandler`fournit deux méthodes qui sont appelées en fonction de la manière dont la demande est terminée : `onSuccess` et`onError`.
Le principal avantage de l'approche de l'interface de rappel est qu'il vous évite d'avoir à interroger l'objet `Future` pour savoir à quel moment la demande est terminée. Au lieu de cela, votre code peut immédiatement commencer son activité suivante et s'appuyer sur le kit SDK pour appeler votre gestionnaire au bon moment.
```
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(".");
}
}
}
```
## Bonnes pratiques
### Exécution des rappels
Votre implémentation de `AsyncHandler` est exécutée à l'intérieur du groupe de threads dont le client asynchrone est propriétaire. Un code bref, rapidement exécuté est le plus approprié à l'intérieur de votre implémentation d' `AsyncHandler`. Un code de longue durée ou un code de blocage à l'intérieur des méthodes de votre gestionnaire peuvent entraîner un conflit au sein du groupe de threads utilisé par le client asynchrone et empêcher le client d'exécuter les demandes. Si vous avez une tâche de longue durée qui doit commencer à partir d'un rappel, faites en sorte que le rappel exécute sa tâche dans un nouveau thread ou dans un groupe de threads géré par votre application.
### Configuration du groupe de threads
Les clients asynchrones du AWS SDK pour Java fournissent un pool de threads par défaut qui devrait fonctionner pour la plupart des applications. Vous pouvez implémenter une personnalisation [ExecutorService](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ExecutorService.html)et la transmettre à des clients AWS SDK pour Java asynchrones pour mieux contrôler la façon dont les pools de threads sont gérés.
Par exemple, vous pouvez fournir une `ExecutorService` implémentation qui utilise un paramètre personnalisé [ThreadFactory](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ThreadFactory.html)pour contrôler le nom des threads du pool ou pour enregistrer des informations supplémentaires sur l'utilisation des threads.
### Accès asynchrone
La [TransferManager](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/TransferManager.html)classe du SDK offre un support asynchrone pour travailler avec. Amazon S3`TransferManager`gère les chargements et téléchargements asynchrones, fournit des rapports d'avancement détaillés sur les transferts et prend en charge les rappels lors de différents événements.
# Enregistrement AWS SDK pour Java des appels
AWS SDK pour Java Il est instrumenté avec [Apache Commons Logging](http://commons.apache.org/proper/commons-logging/guide.html), une couche d'abstraction qui permet d'utiliser l'un des nombreux systèmes de journalisation au moment de l'exécution.
Les systèmes de journalisation pris en charge incluent Java Logging Framework et Apache Log4j, entre autres. Cette section vous explique comment utiliser Log4j. Vous pouvez utiliser la fonction de journalisation du kit SDK sans apporter de modifications au code de votre application.
Pour en savoir plus sur [Log4j](http://logging.apache.org/log4j/2.x/), consultez le [site web Apache](http://www.apache.org/).
**Note**
Cette rubrique se concentre sur Log4j 1.x. Log4j2 ne prend pas directement en charge Apache Commons Logging, mais fournit un adaptateur qui dirige automatiquement la journalisation des appels vers Log4j2 à l'aide de l'interface Apache Commons Logging. Pour plus d'informations, consultez [Commons Logging Bridge](https://logging.apache.org/log4j/2.x/log4j-jcl.html) dans la documentation Log4j2.
## Téléchargement du fichier JAR Log4J
Pour utiliser Log4j avec le kit SDK, vous devez télécharger le fichier JAR Log4j à partir du site web Apache. Le kit SDK n'inclut pas le fichier JAR. Copiez le fichier JAR sur un emplacement de votre chemin de classe.
Log4j utilise un fichier de configuration, log4j.properties. Vous trouverez ci-dessous des exemples de fichiers de configuration. Copiez ce fichier de configuration dans un répertoire de votre chemin de classe. Le fichier JAR Log4j et le fichier log4j.properties ne doivent pas nécessairement se trouver dans le même répertoire.
Le fichier de configuration log4j.properties spécifie les propriétés telles que le [niveau de journalisation](http://logging.apache.org/log4j/2.x/manual/configuration.html#Loggers), l'emplacement vers lequel la sortie de la journalisation est envoyée (par exemple, [vers un fichier ou vers la console](http://logging.apache.org/log4j/2.x/manual/appenders.html)) et le [format de la sortie](http://logging.apache.org/log4j/2.x/manual/layouts.html). Le niveau de journalisation correspond à la granularité de la sortie que l'enregistreur d'événements génère. Log4j prend en charge le concept de *hiérarchies* de journalisation multiples. Le niveau de journalisation est défini de manière indépendante pour chaque hiérarchie. Les deux hiérarchies de journalisation suivantes sont disponibles dans le kit AWS SDK pour Java :
+ log4j.logger.com.amazonaws
+ log4j.logger.org.apache.http.wire
## Définition du chemin de classe
Le fichier JAR Log4j et le fichier log4j.properties doivent se trouver sur votre chemin de classe. Si vous utilisez [Apache Ant](http://ant.apache.org/manual/), définissez le chemin de classe dans l'élément `path` de votre fichier Ant. L'exemple suivant montre un élément de chemin du fichier Ant pour l' Amazon S3 [exemple](https://github.com/aws/aws-sdk-java/blob/master/src/samples/AmazonS3/build.xml) inclus dans le SDK.
```
```
Si vous utilisez l'IDE Eclipse, vous pouvez définir le chemin de classe en ouvrant le menu et en accédant à **Project (Projet)** \$1 **Properties (Propriétés)** \$1 **Java Build Path (Chemin de génération Java)**.
## Erreurs et avertissements propres au service
Nous vous recommandons de toujours laisser la hiérarchie de l'enregistreur d'événements définie avec la valeur « WARN » pour intercepter les messages importants des bibliothèques clientes. Par exemple, si le Amazon S3 client détecte que votre application n'a pas correctement fermé une application `InputStream` et qu'elle est susceptible de provoquer une fuite de ressources, le client S3 le signale par le biais d'un message d'avertissement envoyé aux journaux. Il est ainsi possible de s'assurer que les messages sont enregistrés au cas où le client rencontrerait des problèmes de gestion des demandes ou des réponses.
Le fichier log4j.properties suivant définit `rootLogger` avec la valeur WARN, ce qui entraîne l'inclusion des messages d'avertissement et d'erreur de tous les enregistreurs d'événements de la hiérarchie « com.amazonaws ». Vous pouvez aussi définir explicitement l'enregistreur d'événements com.amazonaws avec la valeur 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
```
## Journalisation récapitulative des demandes et des réponses
Chaque demande envoyée à un Service AWS génère un identifiant de AWS demande unique qui est utile si vous rencontrez un problème avec le traitement d'une demande par an Service AWS . AWS IDs les demandes sont accessibles par programmation via les objets Exception du SDK en cas d'échec d'un appel de service, et peuvent également être signalées via le niveau de journal DEBUG dans l'enregistreur « com.amazonaws.request ».
Le fichier log4j.properties suivant permet de résumer les demandes et les réponses, y compris les demandes. 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
```
Voici un exemple de la sortie du journal.
```
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
```
## Journalisation du réseau filaire détaillée
Dans certains cas, il peut être utile de voir les demandes et réponses exactes qu'ils AWS SDK pour Java envoient et reçoivent. Vous ne devez pas activer cette journalisation dans les systèmes de production, car l'écriture de demandes volumineuses (par exemple, le téléchargement d'un fichier Amazon S3) ou de réponses peut ralentir considérablement une application. Si vous avez vraiment besoin d'accéder à ces informations, vous pouvez les activer temporairement via l'enregistreur Apache HttpClient 4. L'activation du niveau DEBUG sur l'enregistreur d'événements `org.apache.http.wire` permet la journalisation de toutes les données de demande et de réponse.
Le fichier log4j.properties suivant active la journalisation complète dans Apache HttpClient 4 et ne doit être activé que temporairement car cela peut avoir un impact significatif sur les performances de votre application.
```
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
```
## Journalisation des métriques de latence
L'enregistreur d'événements de latence peut s'avérer utile si vous voulez résoudre des problèmes et que vous souhaitez voir des métriques permettant entre autres de déterminer quel processus prend le plus de temps, ou si le côté serveur ou client a la plus grande latence. Définissez l'enregistreur d'événements `com.amazonaws.latency` sur DEBUG pour activer cet enregistreur d'événements.
**Note**
Cet enregistreur d'événements est disponible uniquement si les métriques SDK sont activées. Pour en savoir plus sur le package de métriques du SDK, consultez [Enabling Metrics for the AWS SDK pour 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
```
Voici un exemple de la sortie du journal.
```
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]
```
# Configuration de client
Vous AWS SDK pour Java permet de modifier la configuration par défaut du client, ce qui est utile lorsque vous souhaitez :
+ Se connecter à Internet via un proxy
+ Modifier les paramètres de transport HTTP, tels que le délai de connexion et les nouvelles tentatives de demande
+ Spécifier des conseils sur la taille de la mémoire tampon du socket TCP
## Configuration de proxy
Lorsque vous créez un objet client, vous pouvez transmettre un [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)objet facultatif pour personnaliser la configuration du client.
Si vous vous connectez à Internet via un serveur proxy, vous devez configurer les paramètres du serveur proxy (hôte proxy, port et nom d'utilisateur/mot de passe) via l'objet `ClientConfiguration`.
## Configuration du transport HTTP
Vous pouvez configurer plusieurs options de transport HTTP à l'aide de l'[ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)objet. De nouvelles options sont parfois ajoutées ; pour voir la liste complète des options que vous pouvez récupérer ou définir, consultez la référence de l' AWS SDK pour Java API.
**Note**
Chacune des valeurs configurables possède une valeur par défaut définie par une constante. Pour obtenir la liste des valeurs constantes pour`ClientConfiguration`, consultez la section [Valeurs de champ constantes](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) dans la référence de l' AWS SDK pour Java API.
### Connexions maximales
Vous pouvez définir le nombre maximum autorisé de connexions HTTP ouvertes à l'aide du [ClientConfiguration. setMaxConnections](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxConnections-int-)méthode.
**Important**
Définissez le nombre maximal de connexions de telle sorte qu'il corresponde au nombre de transactions simultanées. Vous éviterez ainsi des contentions de connexions et une dégradation des performances. Pour connaître la valeur maximale de connexions par défaut, consultez la section [Valeurs de champ constantes](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) dans la référence de l' AWS SDK pour Java API.
### Délais et gestion des erreurs
Vous pouvez définir des options liées aux délais et à la gestion des erreurs avec les connexions HTTP.
+ **Délai de connexion**
Le délai de connexion correspond à la durée (en millisecondes) pendant laquelle la connexion HTTP attend pour établir une connexion avant d'abandonner. La valeur par défaut est 10 000 ms.
Pour définir vous-même cette valeur, utilisez le [ClientConfiguration. setConnectionTimeout](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTimeout-int-)méthode.
+ **Durée de vie (TTL) de la connexion**
Par défaut, le kit SDK tente de réutiliser les connexions HTTP aussi longtemps que possible. Dans les situations d'échec où une connexion est établie vers un serveur qui a été mis hors service, le fait d'avoir une durée de vie finie peut aider à la récupération de l'application. Par exemple, la définition d'une durée de vie de 15 minutes garantit que, même si vous avez une connexion établie avec un serveur qui rencontre des problèmes, vous rétablirez une connexion à un nouveau serveur dans un délai de 15 minutes.
Pour définir le TTL de connexion HTTP, utilisez la méthode [ClientConfiguration.setConnectionTTL](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTTL-long-).
+ **Nombre maximal de tentatives en cas d'erreur**
Par défaut, le nombre maximal de tentatives en cas d'erreur est de 3. Vous pouvez définir une valeur différente en utilisant le [ClientConfiguration. setMaxErrorRéessayer](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxErrorRetry-int-) la méthode.
### Adresse locale
Pour définir l'adresse locale à laquelle le client HTTP doit se lier, utilisez [ClientConfiguration. setLocalAddress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setLocalAddress-java.net.InetAddress-).
## Conseils sur la taille de la mémoire tampon du socket TCP
Les utilisateurs expérimentés qui souhaitent ajuster les paramètres TCP de bas niveau peuvent également définir des indications sur la taille de la mémoire tampon TCP via l'objet. [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html) La majorité des utilisateurs n'aura jamais besoin de modifier ces valeurs, mais elles sont fournies pour les utilisateurs avancés.
Les tailles optimales de mémoire tampon TCP d'une application dépendent fortement de la configuration et des capacités du réseau et du système d'exploitation. Par exemple, la plupart des systèmes d'exploitation modernes fournissent une logique de réglage automatique pour les tailles de mémoire tampon de socket TCP. Il peut en résulter un impact important sur les performances des connexions TCP qui sont maintenues ouvertes assez longtemps pour que le réglage automatique optimise les tailles de mémoire tampon.
Les tailles de mémoire tampon élevées (par exemple, 2 Mo) permettent au système d'exploitation de placer en mémoire tampon plus de données sans avoir besoin que le serveur distant accuse réception des informations et peuvent ainsi se révéler particulièrement utiles quand le réseau présente une latence élevée.
Il s'agit uniquement d'un *conseil* ; il se peut que le système d'exploitation ne le suive pas. Lors de l'utilisation de cette option, les utilisateurs doivent toujours vérifier les valeurs par défaut et les limites configurées du système d'exploitation. La plupart des systèmes d'exploitation ont une taille maximale de mémoire tampon TCP et ne vous permettent pas de dépasser ce seuil, sauf si vous augmentez explicitement la taille maximale de la mémoire tampon TCP.
De nombreuses ressources sont disponibles pour vous aider à configurer les tailles de mémoire tampon TCP et les paramètres TCP spécifiques au système d'exploitation, y compris les éléments suivants :
+ [Réglage de l'hôte](http://fasterdata.es.net/host-tuning/)
# Stratégies de contrôle d'accès
AWS *les politiques de contrôle d'accès* vous permettent de définir des contrôles d'accès précis sur vos AWS ressources. Une stratégie de contrôle d'accès se compose d'un ensemble de *déclarations* qui se présentent sous la forme suivante :
Le *compte A* est autorisé à exécuter l'*action B* sur la *ressource C* lorsque la *condition D* s'applique.
Où :
+ *A* est le *principal* : celui Compte AWS qui fait une demande pour accéder à l'une de vos AWS ressources ou pour la modifier.
+ *B* est l'*action* : mode d'accès ou de modification de votre AWS ressource, par exemple en envoyant un message à une Amazon SQS file d'attente ou en stockant un objet dans un Amazon S3 compartiment.
+ *C* est la *ressource* : AWS entité à laquelle le principal souhaite accéder, telle qu'une Amazon SQS file d'attente ou un objet stocké Amazon S3.
+ *D* est un *ensemble de conditions* : les contraintes facultatives qui spécifient quand autoriser ou refuser l'accès au principal pour accéder à votre ressource. De nombreuses conditions expressives sont disponibles, certaines spécifiques à chaque service. Par exemple, vous pouvez utiliser des conditions de date pour autoriser l'accès à vos ressources uniquement après ou avant un moment spécifique.
## Amazon S3 Exemple
L'exemple suivant illustre une politique qui permet à quiconque d'accéder à tous les objets d'un compartiment, mais restreint l'accès au téléchargement d'objets vers ce compartiment à deux options spécifiques Compte AWS(en plus du compte du propriétaire du compartiment).
```
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 Exemple
Les politiques sont couramment utilisées pour autoriser une Amazon SQS file d'attente à recevoir des messages provenant d'une rubrique 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));
```
## Exemple Amazon SNS
Certains services proposent des conditions supplémentaires qui peuvent être utilisées dans les politiques. Amazon SNS fournit les conditions permettant d'autoriser ou de refuser les abonnements aux rubriques SNS en fonction du protocole (e-mail, HTTP, HTTPS, etc. Amazon SQS) et du point de terminaison (adresse e-mail, URL, Amazon SQS ARN) de la demande d'abonnement à une rubrique.
```
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()));
```
# Définissez le TTL de la JVM pour les recherches de noms DNS
La machine virtuelle Java (JVM) met en cache les recherches de nom DNS. Lorsque la JVM convertit un nom d'hôte en adresse IP, elle met l'adresse IP en cache pendant une période spécifiée, connue sous le nom de *time-to-live*(TTL).
Étant donné que les AWS ressources utilisent des entrées de nom DNS qui changent occasionnellement, nous vous recommandons de configurer votre JVM avec une valeur TTL de 5 secondes. Ainsi, lorsque l'adresse IP d'une ressource change, votre application peut recevoir et utiliser la nouvelle adresse IP de la ressource en interrogeant le DNS.
Dans certaines configurations Java, la durée de vie par défaut de la JVM est définie de façon à ce que la JVM n'actualise *jamais* les entrées DNS tant qu'elle n'est pas redémarrée. Ainsi, si l'adresse IP d'une AWS ressource change alors que votre application est toujours en cours d'exécution, elle ne pourra pas utiliser cette ressource tant que vous n'aurez pas *redémarré manuellement* la JVM et que les informations IP mises en cache ne seront pas actualisées. Dans ce cas, il est essentiel de définir la durée de vie de la JVM de façon à ce que ses informations IP mises en cache soient régulièrement actualisées.
## Comment configurer le JVM TTL
Pour modifier le TTL de la JVM, définissez la valeur de la propriété de sécurité [networkaddress.cache.ttl](https://docs.oracle.com/en/java/javase/17/core/java-networking.html#GUID-A680DADB-C4C1-40F1-B568-D9A97C917F5D). Notez qu'il `networkaddress.cache.ttl` s'agit d'une *propriété de sécurité* et non d'une propriété système, c'est-à-dire qu'elle ne peut pas être définie avec l'indicateur de `-D` ligne de commande.
### Option 1 : définissez-le par programmation dans votre application
Appelez [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)au début du démarrage de votre application, avant la création de clients AWS SDK et avant toute demande réseau :
```
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
}
}
```
### Option 2 : définissez-le dans le fichier java.security
Définissez la `networkaddress.cache.ttl` propriété dans le `$JAVA_HOME/jre/lib/security/java.security` fichier pour Java 8 ou dans `$JAVA_HOME/conf/security/java.security` le fichier pour Java 11 ou supérieur.
Ce qui suit est un extrait d'un `java.security` fichier qui montre que le cache TTL est réglé sur 5 secondes.
```
#
# 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
...
```
Toutes les applications qui s'exécutent sur la JVM représentée par la variable d'`$JAVA_HOME`environnement utilisent ce paramètre.
### Option 3 : utiliser la solution de remplacement des propriétés du système JDK (ligne de commande)
Si vous ne pouvez pas modifier la configuration ou le code de sécurité, vous pouvez utiliser les propriétés du système JDK. Ils agissent comme des solutions de secours si aucune propriété de sécurité n'est définie.
+ `sun.net.inetaddr.ttl`— Contrôle les recherches réussies (TTL positif)
+ `sun.net.inetaddr.negative.ttl`— Contrôle les échecs de recherche (TTL négatif)
```
java -Dsun.net.inetaddr.ttl=5 -Dsun.net.inetaddr.negative.ttl=1 -jar myapp.jar
```
**Note**
Il s'agit de propriétés internes au JDK décrites dans la référence aux propriétés [réseau d'Oracle Java 8 en tant que propriétés](https://docs.oracle.com/javase/8/docs/technotes/guides/net/properties.html) privées qui « ne seront peut-être pas prises en charge dans les versions futures ». Utilisez les options 1 et 2 dans la mesure du possible.
# Activation des métriques pour AWS SDK pour Java
Ils AWS SDK pour Java peuvent générer des métriques à des fins de visualisation et de surveillance avec [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) qui mesurent :
+ les performances de votre application lors de l'accès AWS
+ les performances de votre appareil JVMs lorsqu'il est utilisé avec AWS
+ des détails sur l'environnement d'exécution comme la mémoire de segment, le nombre de threads et les descripteurs de fichier ouverts
## Comment activer la génération de métriques du SDK Java
Vous devez ajouter la dépendance Maven suivante pour permettre au SDK d'envoyer des métriques à. CloudWatch
```
com.amazonaws
aws-java-sdk-bom
1.12.490*
pom
import
com.amazonaws
aws-java-sdk-cloudwatchmetrics
provided
```
\$1 Remplacez le numéro de version par la dernière version du SDK disponible sur [Maven Central](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom).
AWS SDK pour Java les métriques sont *désactivées par défaut*. Pour l'activer dans votre environnement de développement local, incluez une propriété système pointant vers votre fichier d'informations AWS de sécurité lors du démarrage de la JVM. Par exemple :
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties
```
Vous devez spécifier le chemin d'accès à votre fichier d'identification afin que le SDK puisse télécharger les points de données collectés pour CloudWatch une analyse ultérieure.
**Note**
Si vous accédez AWS depuis une Amazon EC2 instance à l'aide du service de métadonnées d' Amazon EC2 instance, vous n'avez pas besoin de spécifier de fichier d'informations d'identification. Dans ce cas, vous devez seulement spécifier :
```
-Dcom.amazonaws.sdk.enableDefaultMetrics
```
*Toutes les métriques capturées par le AWS SDK pour Java se trouvent sous l'espace de noms **AWSSDK/Java** et sont téléchargées dans la région CloudWatch par défaut (us-east-1).* Pour changer de région, spécifiez votre région en utilisant l'attribut `cloudwatchRegion` dans la propriété système. Par exemple, pour définir la CloudWatch région sur *us-east-1*, utilisez :
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,cloudwatchRegion={region_api_default}
```
Une fois la fonctionnalité activée, chaque fois qu'une demande de service est envoyée, des points AWS de données métriques sont générés AWS SDK pour Java, mis en file d'attente pour un résumé statistique et téléchargés de manière asynchrone CloudWatch environ une fois par minute. Une fois les métriques téléchargées, vous pouvez les visualiser à l'aide de [AWS Management Console](https://console.aws.amazon.com/console/home)et définir des alarmes en cas de problèmes potentiels tels que les fuites de mémoire, les fuites de descripteurs de fichiers, etc.
## Types de métrique disponibles
L'ensemble de métriques par défaut est divisé en trois catégories principales :
AWS Métriques des demandes
+ Couvrent des domaines tels que la latence de la demande/réponse HTTP, le nombre de demandes, les exceptions et les nouvelles tentatives.
![\[RequestMetric 131111\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/v1/developer-guide/images/RequestMetric-131111.png)
Service AWS Métriques
+ Incluez Service AWS des données spécifiques, telles que le débit et le nombre d'octets pour les chargements et téléchargements S3.
![\[ServiceMetric 131111\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/v1/developer-guide/images/ServiceMetric-131111.png)
Métriques machine
+ Couvrent l'environnement d'exécution, y compris la mémoire de segment, le nombre de threads et les descripteurs de fichier ouverts.
![\[MachineMetric 131111\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/v1/developer-guide/images/MachineMetric-131111.png)
Si vous souhaitez exclure les métriques machine, ajoutez `excludeMachineMetrics` à la propriété système :
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,excludeMachineMetrics
```
## En savoir plus
+ Consultez le [récapitulatif du package amazonaws/metrics](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/package-summary.html) pour voir la liste complète des types de métriques de base prédéfinies.
+ Découvrez comment CloudWatch utiliser le AWS SDK pour Java dans [CloudWatch Exemples d'utilisation du AWS SDK pour Java](examples-cloudwatch.md).
+ Pour en savoir plus sur le réglage des performances, consultez [le billet de blog Tuning the AWS SDK pour Java to Improve Resiliency](https://aws.amazon.com/blogs/developer/tuning-the-aws-sdk-for-java-to-improve-resiliency).