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 pour Rust
<a name="endpoints"></a>

Lorsqu'il AWS SDK pour Rust appelle an Service AWS, l'une de ses premières étapes consiste à déterminer où acheminer la demande. Ce processus est connu sous le nom de résolution des terminaux.

Vous pouvez configurer la résolution des points de terminaison pour le SDK lorsque vous créez un client de service. La configuration par défaut pour la résolution des points de terminaison est généralement correcte, mais il existe plusieurs raisons pour lesquelles vous souhaiterez peut-être modifier la configuration par défaut. Voici deux exemples de raisons :
+ Pour adresser des demandes à une version préliminaire d'un service ou à un déploiement local d'un service.
+ Pour accéder à des fonctionnalités de service spécifiques qui ne sont pas encore modélisées dans le SDK.

**Avertissement**  
La résolution des points de terminaison est une rubrique avancée du SDK. Si vous modifiez les paramètres par défaut, vous risquez de casser votre code. Les paramètres par défaut s'appliquent à la plupart des utilisateurs dans les environnements de production.

Les points de terminaison personnalisés peuvent être définis globalement afin qu'ils soient utilisés pour toutes les demandes de service, ou vous pouvez définir un point de terminaison personnalisé pour un point spécifique Service AWS.

Les points de terminaison personnalisés peuvent être configurés à l'aide de variables d'environnement ou de paramètres du AWS `config` fichier partagé. Pour plus d'informations sur cette approche, consultez la section [Points de terminaison spécifiques au service](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) dans le Guide de référence des *outils AWS SDKs et des outils*. Pour obtenir la liste complète des paramètres de `config` fichiers partagés et des variables d'environnement pour tous Services AWS, consultez la section [Identifiants pour les points de terminaison spécifiques à un service](https://docs.aws.amazon.com/sdkref/latest/guide/ss-endpoints-table.html).

 Cette personnalisation peut également être configurée dans votre code, comme indiqué dans les sections suivantes.

## Configuration personnalisée
<a name="custom-configuration"></a>

Vous pouvez personnaliser la résolution des points de terminaison d'un client de service à l'aide de deux méthodes disponibles lorsque vous créez le client :

1. `endpoint_url(url: Into<String>)`

1. `endpoint_resolver(resolver: impl crate::config::endpoint::ResolveEndpoint + `static)`

Vous pouvez définir les deux propriétés. Cependant, le plus souvent, vous n'en fournissez qu'un. Pour un usage général, `endpoint_url` il est le plus souvent personnalisé.

### Définir l'URL du point final
<a name="set-endpoint-url"></a>

Vous pouvez définir une valeur pour `endpoint_url` pour indiquer un nom d'hôte « de base » pour le service. Cette valeur n'est toutefois pas définitive puisqu'elle est transmise en tant que paramètre à l'`ResolveEndpoint`instance du client. L'`ResolveEndpoint`implémentation peut ensuite inspecter et éventuellement modifier cette valeur pour déterminer le point final.

### Définir le résolveur de point de terminaison
<a name="set-endpoint-resolver"></a>

L'`ResolveEndpoint`implémentation d'un client de service détermine le point final résolu que le SDK utilise pour une demande donnée. Un client de service appelle la `resolve_endpoint` méthode pour chaque demande et utilise la [https://docs.rs/aws-smithy-runtime-api/latest/aws_smithy_runtime_api/client/endpoint/struct.EndpointFuture.html](https://docs.rs/aws-smithy-runtime-api/latest/aws_smithy_runtime_api/client/endpoint/struct.EndpointFuture.html)valeur renvoyée par le résolveur sans autre modification.

L'exemple suivant montre comment fournir une implémentation de résolveur de point de terminaison personnalisée pour un client Amazon S3 qui résout un point de terminaison différent par étape, comme le développement et la production :

```
use aws_sdk_s3::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};

#[derive(Debug)]
struct StageResolver { stage: String }
impl ResolveEndpoint for StageResolver {
    fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
        let stage = &self.stage;
        EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
    }
}


let config = aws_config::defaults(BehaviorVersion::latest())
    .load()
    .await;

let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };

let s3_config = aws_sdk_s3::config::Builder::from(&config)
    .endpoint_resolver(resolver)
    .build();

let s3 = aws_sdk_s3::Client::from_conf(s3_config);
```

**Note**  
Les résolveurs de points de terminaison, et par extension le `ResolveEndpoint` trait, sont spécifiques à chaque service et ne peuvent donc être configurés que dans la configuration du client du service. L'URL du point de terminaison, quant à elle, peut être configurée soit à l'aide d'une configuration partagée (applicable à tous les services dérivés), soit pour un service spécifique.

#### ResolveEndpoint paramètres
<a name="resolveendpoint-parameters"></a>

La `resolve_endpoint` méthode accepte les paramètres spécifiques au service qui contiennent les propriétés utilisées dans la résolution des points de terminaison.

Chaque service inclut les propriétés de base suivantes :


| Nom | Type | Description | 
| --- | --- | --- | 
| region | String | Celui du client Région AWS | 
| endpoint | String | Une représentation sous forme de chaîne de l'ensemble de valeurs de endpointUrl | 
| use\$1fips | Booléen | Si les points de terminaison FIPS sont activés dans la configuration du client | 
| use\$1dual\$1stack | Booléen | Si les points de terminaison à double pile sont activés dans la configuration du client | 

Services AWS peut spécifier des propriétés supplémentaires requises pour la résolution. Par exemple, les [paramètres du point de terminaison](https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/config/endpoint/struct.Params.html) Amazon S3 incluent le nom du compartiment ainsi que plusieurs paramètres de fonctionnalités spécifiques à Amazon S3. Par exemple, la `force_path_style` propriété détermine si l'adressage d'hôte virtuel peut être utilisé.

Si vous implémentez votre propre fournisseur, vous ne devriez pas avoir à créer votre propre instance de paramètres de point de terminaison. Le SDK fournit les propriétés de chaque demande et les transmet à votre implémentation de`resolve_endpoint`.

### Comparez l'utilisation `endpoint_url` à l'utilisation `endpoint_resolver`
<a name="endpoint-url-or-endpoint-resolver"></a>

Il est important de comprendre que les deux configurations suivantes, l'une qui utilise `endpoint_url` et l'autre qui utilise`endpoint_resolver`, NE produisent PAS de clients présentant un comportement de résolution de point de terminaison équivalent.

```
use aws_sdk_s3::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};

#[derive(Debug, Default)]
struct CustomResolver;
impl ResolveEndpoint for CustomResolver {
    fn resolve_endpoint(&self, _params: &Params) -> EndpointFuture<'_> {
        EndpointFuture::ready(Ok(Endpoint::builder().url("https://endpoint.example").build()))
    }
}

let config = aws_config::defaults(BehaviorVersion::latest())
    .load()
    .await;

// use endpoint url
aws_sdk_s3::config::Builder::from(&config)
    .endpoint_url("https://endpoint.example")
    .build();
    
// Use endpoint resolver
aws_sdk_s3::config::Builder::from(&config)
    .endpoint_resolver(CustomResolver::default())
    .build();
```

Le client qui définit le `endpoint_url` spécifie une URL de *base* qui est transmise au fournisseur (par défaut), qui peut être modifiée dans le cadre de la résolution du point de terminaison.

Le client qui définit le `endpoint_resolver` spécifie l'URL *finale* utilisée par le client Amazon S3.

## Exemples
<a name="endpointsExamples"></a>

Les points de terminaison personnalisés sont souvent utilisés pour les tests. Au lieu de passer des appels vers le service basé sur le cloud, les appels sont acheminés vers un service simulé hébergé localement. Deux de ces options sont les suivantes :
+ [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) local : version locale du service Amazon DynamoDB.
+ [LocalStack](https://github.com/localstack/localstack): un émulateur de service cloud qui s'exécute dans un conteneur sur votre machine locale.

 Les exemples suivants illustrent deux manières différentes de spécifier un point de terminaison personnalisé pour utiliser ces deux options de test.

### Utiliser DynamoDB local directement dans le code
<a name="endpointsExamplesddb"></a>

Comme décrit dans les sections précédentes, vous pouvez définir `endpoint_url` directement dans le code le remplacement du point de terminaison de base afin qu'il pointe vers le serveur DynamoDB local. Dans votre code :

```
    let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
        .test_credentials()
        // DynamoDB run locally uses port 8000 by default.
        .endpoint_url("http://localhost:8000")
        .load()
        .await;
    let dynamodb_local_config = aws_sdk_dynamodb::config::Builder::from(&config).build();

    let client = aws_sdk_dynamodb::Client::from_conf(dynamodb_local_config);
```

L'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb/src/bin/list-tables-local.rs) est disponible sur GitHub.

### Utilisation LocalStack à l'aide du `config` fichier
<a name="endpointsExamplesLs"></a>

Vous pouvez définir des [points de terminaison spécifiques au service](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) dans votre fichier partagé. AWS `config` Le profil de configuration suivant est `endpoint_url` configuré pour se connecter `localhost` à un port`4566`. Pour plus d'informations sur la LocalStack configuration, consultez [Accès LocalStack via l'URL du point de terminaison](https://docs.localstack.cloud/references/network-troubleshooting/endpoint-url/) sur le site Web de la *LocalStackdocumentation*.

```
[profile localstack]
region=us-east-1
endpoint_url = http://localhost:4566
```

Le SDK récupérera les modifications apportées au `config` fichier partagé et les appliquera à vos clients du SDK lorsque vous utiliserez le `localstack` profil. En utilisant cette approche, votre code n'a pas besoin d'inclure de référence aux points de terminaison et ressemblerait à ce qui suit :

```
    // set the environment variable `AWS_PROFILE=localstack` when running
    // the application to source `endpoint_url` and point the SDK at the
    // localstack instance
    let config = aws_config::defaults(BehaviorVersion::latest()).load().await;

    let s3_config = aws_sdk_s3::config::Builder::from(&config)
        .force_path_style(true)
        .build();

    let s3 = aws_sdk_s3::Client::from_conf(s3_config);
```

L'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/localstack) est disponible sur GitHub.