Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurazione degli endpoint client in AWS SDK per Rust
Quando AWS SDK per Rust chiama un Servizio AWS, uno dei primi passi consiste nel determinare dove indirizzare la richiesta. Questo processo è noto come risoluzione degli endpoint.
Puoi configurare la risoluzione degli endpoint per l'SDK quando crei un client di servizio. La configurazione predefinita per la risoluzione degli endpoint in genere va bene, ma ci sono diversi motivi per cui potresti voler modificare la configurazione predefinita. Due esempi di motivi sono i seguenti:
+ Per effettuare richieste a una versione non definitiva di un servizio o a una distribuzione locale di un servizio.
+ Per accedere a funzionalità di servizio specifiche non ancora modellate nell'SDK.
**avvertimento**
La risoluzione degli endpoint è un argomento SDK avanzato. Se modifichi le impostazioni predefinite, rischi di violare il codice. Le impostazioni predefinite si applicano alla maggior parte degli utenti negli ambienti di produzione.
Gli endpoint personalizzati possono essere impostati globalmente in modo da essere utilizzati per tutte le richieste di servizio oppure è possibile impostare un endpoint personalizzato per uno specifico. Servizio AWS
Gli endpoint personalizzati possono essere configurati utilizzando variabili o impostazioni di ambiente nel file condiviso. AWS `config` Per informazioni su questo approccio, consulta [Endpoint specifici del servizio](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) nella Guida di riferimento agli strumenti *AWS SDKs e* agli strumenti. Per l'elenco completo delle impostazioni dei `config` file condivisi e delle variabili di ambiente per tutti Servizi AWS, consulta [Identificatori](https://docs.aws.amazon.com/sdkref/latest/guide/ss-endpoints-table.html) per endpoint specifici del servizio.
In alternativa, questa personalizzazione può essere configurata anche nel codice, come illustrato nelle sezioni seguenti.
## Configurazione personalizzata
È possibile personalizzare la risoluzione degli endpoint di un client di servizio con due metodi disponibili al momento della creazione del client:
1. `endpoint_url(url: Into)`
1. `endpoint_resolver(resolver: impl crate::config::endpoint::ResolveEndpoint + `static)`
È possibile impostare entrambe le proprietà. Tuttavia, molto spesso ne fornisci solo una. Per uso generale, `endpoint_url` è più frequentemente personalizzato.
### Imposta l'URL dell'endpoint
È possibile impostare un valore `endpoint_url` per indicare un nome host «base» per il servizio. Questo valore, tuttavia, non è definitivo poiché viene passato come parametro all'`ResolveEndpoint`istanza del client. L'`ResolveEndpoint`implementazione può quindi ispezionare e potenzialmente modificare quel valore per determinare l'endpoint finale.
### Imposta il resolver degli endpoint
`ResolveEndpoint`L'implementazione di un client di servizio determina l'endpoint risolto finale che l'SDK utilizza per una determinata richiesta. Un client di servizio chiama il `resolve_endpoint` metodo per ogni richiesta e utilizza il [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)valore restituito dal resolver senza ulteriori modifiche.
L'esempio seguente dimostra la fornitura di un'implementazione di endpoint resolver personalizzata per un client Amazon S3 che risolve un endpoint diverso per fase, come lo staging e la produzione:
```
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);
```
**Nota**
I resolver per endpoint, e per estensione la `ResolveEndpoint` caratteristica, sono specifici per ogni servizio e quindi possono essere configurati solo nella configurazione del client del servizio. L'URL dell'endpoint, d'altra parte, può essere configurato utilizzando la configurazione condivisa (applicabile a tutti i servizi da essa derivati) o per un servizio specifico.
#### ResolveEndpoint parametri
Il `resolve_endpoint` metodo accetta parametri specifici del servizio che contengono le proprietà utilizzate nella risoluzione degli endpoint.
Ogni servizio include le seguenti proprietà di base:
| Name | Tipo | Description |
| --- | --- | --- |
| region | Stringa | Del cliente Regione AWS |
| endpoint | Stringa | Una rappresentazione in formato stringa del set di valori di endpointUrl |
| use\_fips | Booleano | Se gli endpoint FIPS sono abilitati nella configurazione del client |
| use\_dual\_stack | Booleano | Se gli endpoint dual-stack sono abilitati nella configurazione del client |
Servizi AWS può specificare proprietà aggiuntive richieste per la risoluzione. Ad esempio, i [parametri degli endpoint](https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/config/endpoint/struct.Params.html) di Amazon S3 includono il nome del bucket e anche diverse impostazioni di funzionalità specifiche di Amazon S3. Ad esempio, la `force_path_style` proprietà determina se è possibile utilizzare l'indirizzamento dell'host virtuale.
Se si implementa il proprio provider, non dovrebbe essere necessario creare un'istanza personalizzata dei parametri degli endpoint. L'SDK fornisce le proprietà per ogni richiesta e le trasmette all'implementazione di. `resolve_endpoint`
### Confronta l'utilizzo con `endpoint_url` l'utilizzo `endpoint_resolver`
È importante comprendere che le due configurazioni seguenti, una che utilizza `endpoint_url` e l'altra che utilizza`endpoint_resolver`, NON producono client con un comportamento di risoluzione degli endpoint equivalente.
```
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();
```
Il client che imposta il `endpoint_url` specifica un URL di *base* che viene passato al provider (predefinito), che può essere modificato come parte della risoluzione degli endpoint.
Il client che imposta il `endpoint_resolver` specifica l'URL *finale utilizzato* dal client Amazon S3.
## Esempi
Gli endpoint personalizzati vengono spesso utilizzati per i test. Invece di effettuare chiamate verso il servizio basato sul cloud, le chiamate vengono indirizzate a un servizio simulato ospitato localmente. Due di queste opzioni sono:
+ [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) local: una versione locale del servizio Amazon DynamoDB.
+ [LocalStack](https://github.com/localstack/localstack)— un emulatore di servizi cloud che viene eseguito in un contenitore sul computer locale.
Gli esempi seguenti illustrano due modi diversi per specificare un endpoint personalizzato per utilizzare queste due opzioni di test.
### Usa DynamoDB local direttamente nel codice
Come descritto nelle sezioni precedenti, è possibile impostare `endpoint_url` direttamente nel codice l'override dell'endpoint di base in modo che punti al server DynamoDB locale. Nel tuo codice:
```
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'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb/src/bin/list-tables-local.rs) è disponibile su GitHub.
### Usa LocalStack usando il `config` file
Puoi impostare [endpoint specifici del servizio](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) nel tuo file condiviso. AWS `config` I seguenti set di profili di configurazione `endpoint_url` a cui connettersi `localhost` sulla porta. `4566` Per ulteriori informazioni sulla LocalStack configurazione, consulta [Accesso LocalStack tramite l'URL dell'endpoint sul sito Web](https://docs.localstack.cloud/references/network-troubleshooting/endpoint-url/) dei *LocalStackdocumenti.*
```
[profile {{localstack}}]
region=us-east-1
endpoint_url = http://localhost:4566
```
L'SDK raccoglierà le modifiche nel `config` file condiviso e le applicherà ai client SDK quando utilizzi il profilo. `localstack` Utilizzando questo approccio, il codice non deve includere alcun riferimento agli endpoint e avrebbe il seguente aspetto:
```
// 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'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/localstack) è disponibile su. GitHub