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.

# Configuration des points de terminaison clients dans le AWS SDK for Java 2.x
<a name="endpoint-config"></a>

Le SDK pour Java 2.x propose plusieurs méthodes pour configurer les points de terminaison de service. Un point de terminaison est l'URL que le SDK utilise pour effectuer des appels d' Services AWS API. Par défaut, le SDK détermine automatiquement le point de terminaison approprié pour chaque service en fonction de celui que Région AWS vous avez configuré. Cependant, il existe des scénarios dans lesquels vous devrez peut-être personnaliser ou remplacer ces points de terminaison : 
+ Travailler avec des implémentations de services locaux ou tiers (telles que LocalStack)
+ Connexion Services AWS via un proxy ou un point de terminaison VPC
+ Tests réalisés sur des points de terminaison de service en version bêta ou en version préliminaire

## Options de configuration des terminaux
<a name="endpoint-configuration-options"></a>

 AWS SDK for Java 2.x Il propose plusieurs méthodes pour configurer les points de terminaison : 
+ Configuration intégrée au code à l'aide du générateur de clients de services
+ Configuration externe avec variables d'environnement
+ Configuration externe avec propriétés du système JVM
+ Configuration externe avec fichier de AWS configuration partagé

## Configuration du point de terminaison intégrée au code
<a name="in-code-endpoint-configuration"></a>

### Utiliser `endpointOverride`
<a name="endpoint-override"></a>

 Le moyen le plus direct de configurer un point de terminaison consiste à utiliser la `endpointOverride` méthode du générateur de clients de services. Cette méthode accepte un `URI` objet représentant l'URL du point de terminaison personnalisé. 

**Example Configuration d'un point de terminaison personnalisé pour un client Amazon S3**  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import java.net.URI;

S3Client s3 = S3Client.builder()
        .region(Region.US_WEST_2)
        .endpointOverride(URI.create("https://my-custom-s3-endpoint.example.com"))
        .build();
```

Lors de l'utilisation`endpointOverride`, vous devez toujours spécifier une région pour le client, même si le point de terminaison est défini explicitement. La région est utilisée pour signer les demandes. 

### Découverte du points de terminaison
<a name="endpoint-discovery"></a>

Certains Services AWS prennent en charge la découverte des terminaux, grâce à laquelle le SDK peut automatiquement découvrir le point de terminaison optimal à utiliser. Vous pouvez activer ou désactiver cette fonctionnalité à l'aide de la `endpointDiscoveryEnabled` méthode du générateur de clients de services. 

**Example Activation de la découverte des terminaux pour un client DynamoDB**  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;

DynamoDbClient dynamoDb = DynamoDbClient.builder()
        .region(Region.US_WEST_2)
        .endpointDiscoveryEnabled(true)
        .build();
```

## Configuration du point de terminaison au niveau de la demande
<a name="request-level-endpoint-configuration"></a>

Dans certains cas, vous devrez peut-être remplacer le point de terminaison pour une demande spécifique tout en utilisant le même client pour d'autres demandes avec le point de terminaison par défaut. Cela est pris AWS SDK for Java 2.x en charge par le biais de remplacements de demandes. 

**Example Remplacer le point de terminaison pour une demande spécifique**  

```
import software.amazon.awssdk.core.SdkRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.http.SdkHttpRequest;

S3Client s3 = S3Client.builder()
        .region(Region.US_WEST_2)
        .build();

// Create a request
GetObjectRequest getObjectRequest = GetObjectRequest.builder()
        .bucket("amzn-s3-demo-bucket")
        .key("my-key")
        .overrideConfiguration(c -> c.putHeader("Host", "custom-endpoint.example.com"))
        .build();

// Execute the request with the custom endpoint
s3.getObject(getObjectRequest);
```

Notez que les remplacements de point de terminaison au niveau de la demande sont limités et peuvent ne pas fonctionner pour tous les services ou scénarios. Dans la plupart des cas, il est recommandé d'utiliser une configuration de point de terminaison au niveau du client. 

## Configuration du point de terminaison externe
<a name="external-endpoint-configuration"></a>

### Utilisation des variables d’environnement
<a name="environment-variables-for-endpoints"></a>

Vous pouvez configurer les points de terminaison à l'aide de variables d'environnement. Le SDK prend en charge la configuration des points de terminaison spécifiques au service par le biais de variables d'environnement au format`AWS_ENDPOINT_URL_[SERVICE]`, où `[SERVICE]` est l'identifiant de service en majuscules. 

**Example Configuration d'un point de terminaison S3 à l'aide de variables d'environnement**  

```
# For Linux/macOS
export AWS_ENDPOINT_URL_S3=https://my-custom-s3-endpoint.example.com

# For Windows
set AWS_ENDPOINT_URL_S3=https://my-custom-s3-endpoint.example.com
```

 Vous pouvez également définir un préfixe ou un suffixe d'URL de point de terminaison global à l'aide des variables d'environnement suivantes : 
+ `AWS_ENDPOINT_URL`- Définit un point de terminaison global pour tous les services
+ `AWS_ENDPOINT_URL_PREFIX`- Ajoute un préfixe à tous les points de terminaison de service
+ `AWS_ENDPOINT_URL_SUFFIX`- Ajoute un suffixe à tous les points de terminaison de service

### Utilisation des propriétés du système JVM
<a name="jvm-system-properties-for-endpoints"></a>

 Vous pouvez également configurer les points de terminaison à l'aide des propriétés du système JVM. Le format est similaire à celui des variables d'environnement mais utilise une convention de dénomination différente. 

**Example Configuration d'un point de terminaison S3 à l'aide des propriétés du système JVM**  

```
java -Daws.endpointUrl.s3=https://my-custom-s3-endpoint.example.com -jar your-application.jar
```

 La configuration globale du point de terminaison est également disponible via les propriétés du système : 
+ `aws.endpointUrl`- Définit un point de terminaison global pour tous les services
+ `aws.endpointUrl.prefix`- Ajoute un préfixe à tous les points de terminaison de service
+ `aws.endpointUrl.suffix`- Ajoute un suffixe à tous les points de terminaison de service

### Utilisation du fichier de AWS configuration partagé
<a name="aws-config-file-for-endpoints"></a>

 AWS SDK for Java 2.x Il prend également en charge la configuration des terminaux via le fichier de AWS configuration partagé, généralement situé dans `~/.aws/config` (Linux/macOS) ou `%USERPROFILE%\.aws\config` (Windows). Consultez le [guide de référence AWS SDKs et des outils](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html#ss-endpoints-config) pour obtenir des informations et des exemples.

## Ordre de priorité de configuration
<a name="endpoint-configuration-precedence"></a>

 Lorsque plusieurs configurations de point de terminaison sont présentes, le SDK suit cet ordre de priorité (du plus élevé au plus bas) : 

1. Dérogations au niveau de la demande (le cas échéant)

1. Configuration au niveau du client via `endpointOverride`

1. Variables d'environnement

1. Propriétés du système JVM

1. Fichier de AWS configuration partagé

1. Points de terminaison par défaut basés sur les paramètres configurés Région AWS

## Configuration du point de terminaison spécifique au service
<a name="service-specific-endpoint-configuration"></a>

 Certains Services AWS proposent des options de configuration de point de terminaison supplémentaires spécifiques à ce service. Voici quelques exemples: 

### Configuration du point de terminaison Amazon S3
<a name="s3-endpoint-configuration"></a>

 Amazon S3 prend en charge plusieurs configurations de point de terminaison par le biais de la `S3Configuration` classe : 
+ `dualstackEnabled`- Permet le IPv6 support
+ `accelerateModeEnabled`- Active l'accélération des transferts S3
+ `pathStyleAccessEnabled`- Utilise un accès de type chemin au lieu d'un style hébergé virtuellement
+ `useArnRegionEnabled`- Utilise la région d'un ARN pour les requêtes interrégionales
+ `fipsModeEnabled`- Achemine les demandes vers des points de terminaison conformes à la norme FIPS

**Example Configuration des options de point de terminaison spécifiques à S3**  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.S3Configuration;

S3Client s3 = S3Client.builder()
        .region(Region.US_WEST_2)
        .serviceConfiguration(S3Configuration.builder()
                .accelerateModeEnabled(true)
                .dualstackEnabled(true)
                .pathStyleAccessEnabled(false)
                .fipsModeEnabled(true)
                .build())
        .build();
```

### Configuration du point de terminaison DynamoDB
<a name="dynamodb-endpoint-configuration"></a>

 Pour DynamoDB, vous pouvez utiliser la découverte des points de terminaison ou vous connecter à [DynamoDB local pour tester](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) : 

**Example Connexion à DynamoDB en local**  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import java.net.URI;

DynamoDbClient dynamoDb = DynamoDbClient.builder()
        .endpointOverride(URI.create("http://localhost:8000"))
        // The region is meaningless for DynamoDB local but required for the client builder.
        .region(Region.US_WEST_2)
        .build();
```

DynamoDB prend également en charge l'utilisation de points de terminaison [basés sur des comptes](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html), que vous pouvez configurer dans le code ou à l'aide de paramètres externes. *L'exemple suivant montre comment désactiver l'utilisation de points de terminaison basés sur un compte dans le code lorsque vous créez le client (les paramètres par défaut sont préférés) :*

```
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
    .region(Region.US_EAST_1)
    .accountIdEndpointMode(AccountIdEndpointMode.DISABLED)
    .build();
```

## Bonnes pratiques
<a name="endpoint-configuration-best-practices"></a>

 Lorsque vous configurez des points de terminaison dans le AWS SDK for Java 2.x, tenez compte des meilleures pratiques suivantes : 
+  *Utiliser une configuration externe pour les points de terminaison spécifiques à l'environnement* : utilisez les variables d'environnement, les propriétés du système ou le fichier de AWS configuration pour les points de terminaison qui varient d'un environnement à l'autre (développement, test, production). 
+  *Utiliser la configuration intégrée au code pour les points de terminaison spécifiques à l'application* : utilisez la `endpointOverride` méthode du générateur de clients pour les points de terminaison spécifiques à la conception de votre application. 
+  *Spécifiez toujours une région* —Même lorsque vous remplacez des points de terminaison, spécifiez toujours une région telle qu'elle est utilisée pour la signature des demandes. 
+  *Soyez prudent en ce qui concerne les remplacements de points de terminaison globaux* : l'utilisation de remplacements de points de terminaison globaux peut affecter tous les services, ce qui n'est peut-être pas ce que vous souhaitez. 
+  *Tenez compte des implications en matière de sécurité* : lorsque vous utilisez des points de terminaison personnalisés, assurez-vous qu'ils disposent de mesures de sécurité appropriées, en particulier pour les charges de travail de production.