As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Configurando endpoints do cliente no AWS SDK para Rust
<a name="endpoints"></a>

Quando ele AWS SDK para Rust chama um AWS service (Serviço da AWS), uma de suas primeiras etapas é determinar para onde encaminhar a solicitação. O processo é conhecido como resolução de endpoint.

Você pode configurar a resolução de endpoint para o SDK ao criar um cliente de serviço. A configuração padrão para resolução de endpoints geralmente é boa, mas há vários motivos pelos quais você pode querer modificar a configuração padrão. Estes são dois exemplos de motivos:
+ Para fazer solicitações para uma versão de pré-lançamento de um serviço ou para uma implantação local de um serviço.
+ Para acessar recursos de serviço específicos ainda não modelados no SDK.

**Atenção**  
A resolução de endpoints é um tópico avançado do SDK. Se você alterar as configurações padrão, corre o risco de quebrar seu código. As configurações padrão se aplicam à maioria dos usuários em ambientes de produção.

Os endpoints personalizados podem ser definidos globalmente para que sejam usados em todas as solicitações de serviço, ou você pode definir um endpoint personalizado para um específico. AWS service (Serviço da AWS)

Os endpoints personalizados podem ser configurados usando variáveis de ambiente ou configurações no AWS `config` arquivo compartilhado. Para obter informações sobre essa abordagem, consulte [Endpoints específicos do serviço](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*. Para obter a lista completa de configurações de `config` arquivos compartilhados e variáveis de ambiente para todos Serviços da AWS, consulte [Identificadores para endpoints específicos do serviço](https://docs.aws.amazon.com/sdkref/latest/guide/ss-endpoints-table.html).

 Como alternativa, essa personalização também pode ser configurada no código, conforme mostrado nas seções a seguir.

## Configuração personalizada
<a name="custom-configuration"></a>

Você pode personalizar a resolução do endpoint de um cliente de serviço com dois métodos que estão disponíveis ao criar o cliente:

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

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

Você pode definir ambas as propriedades. No entanto, na maioria das vezes você fornece apenas um. Para uso geral, o `endpoint_url` é personalizado com mais frequência.

### Configurar URL do endpoint
<a name="set-endpoint-url"></a>

Você pode definir um valor para `endpoint_url` para indicar um nome de host “base” para o serviço. Esse valor, no entanto, não é final, pois é passado como parâmetro para a instância `ResolveEndpoint` do cliente. A implementação `ResolveEndpoint` pode então inspecionar e potencialmente modificar esse valor para determinar o endpoint final.

### Definir o endpoint do resolvedor
<a name="set-endpoint-resolver"></a>

A implementação `ResolveEndpoint` de um cliente de serviço determina o endpoint final resolvido que o SDK usa para qualquer solicitação específica. Um cliente de serviço chama o método `resolve_endpoint` para cada solicitação e usa o valor [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) retornado pelo resolvedor sem mais alterações.

O exemplo a seguir demonstra o fornecimento de uma implementação personalizada de resolvedor de endpoint para um cliente do Amazon S3 que resolve um endpoint diferente por estágio, como preparação e produção:

```
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**  
Os resolvedores de endpoint e, por extensão, a característica `ResolveEndpoint`, são específicos para cada serviço e, portanto, só podem ser configurados na configuração do cliente de serviço. O URL do endpoint, por outro lado, pode ser configurado usando configuração compartilhada (aplicável a todos os serviços derivados dela) ou para um serviço específico.

#### ResolveEndpoint parâmetros
<a name="resolveendpoint-parameters"></a>

O método `resolve_endpoint` aceita parâmetros específicos do serviço que contêm propriedades usadas na resolução de endpoints.

Cada serviço inclui as seguintes propriedades de base:


| Nome | Tipo | Description | 
| --- | --- | --- | 
| region | String | Do cliente Região da AWS | 
| endpoint | String | Uma representação de string conjunto de valores de endpointUrl | 
| use\_fips | Booleano | Se os endpoints FIPS estiverem habilitados na configuração do cliente | 
| use\_dual\_stack | Booleano | Se os endpoints de pilha dupla estiverem habilitados na configuração do cliente | 

Serviços da AWS pode especificar propriedades adicionais necessárias para a resolução. Por exemplo, os [parâmetros de endpoint](https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/config/endpoint/struct.Params.html) do Amazon S3 incluem o nome do bucket e também várias configurações de recursos específicos do Amazon S3. Por exemplo, a propriedade `force_path_style` determina se o endereço do host virtual pode ser usado.

Se você implementar seu próprio provedor, não precisará construir sua própria instância de parâmetros de endpoint. O SDK fornece as propriedades de cada solicitação e as passa para sua implementação do `resolve_endpoint`.

### Compare o uso de `endpoint_url` com o uso de `endpoint_resolver`
<a name="endpoint-url-or-endpoint-resolver"></a>

É importante entender que as duas configurações a seguir, uma que usa `endpoint_url` e outra que usa `endpoint_resolver`, NÃO produzem clientes com comportamento de resolução de 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();
```

O cliente que define o `endpoint_url` especifica um URL de *base* passado para o provedor (padrão), que pode ser modificado como parte da resolução do endpoint.

O cliente que define o `endpoint_resolver` especifica o URL *final* que o cliente do Amazon S3 usa.

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

Os endpoints personalizados são frequentemente usados para testes. Em vez de fazer chamadas para o serviço baseado em nuvem, as chamadas são roteadas para um serviço simulado hospedado localmente. Duas dessas opções são:
+ [DynamoDB local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html): uma versão local do serviço Amazon DynamoDB.
+ [LocalStack](https://github.com/localstack/localstack)— um emulador de serviços em nuvem que é executado em um contêiner em sua máquina local.

 Os exemplos a seguir ilustram duas maneiras diferentes de especificar um endpoint personalizado para usar essas duas opções de teste.

### Use o DynamoDB local diretamente no código
<a name="endpointsExamplesddb"></a>

Conforme descrito nas seções anteriores, você pode definir o `endpoint_url` diretamente no código para substituir o endpoint de base para apontar para o servidor local do DynamoDB. No seu código:

```
    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);
```

O [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb/src/bin/list-tables-local.rs) está disponível em GitHub.

### Use LocalStack usando o `config` arquivo
<a name="endpointsExamplesLs"></a>

Você pode definir [endpoints específicos do serviço](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) em seu arquivo compartilhado. AWS `config` O perfil de configuração a seguir define `endpoint_url` para conexão com `localhost` na porta `4566`. Para obter mais informações sobre LocalStack configuração, consulte [Acesso LocalStack por meio da URL do endpoint no site](https://docs.localstack.cloud/references/network-troubleshooting/endpoint-url/) de *LocalStackdocumentos.*

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

O SDK coletará as alterações no arquivo `config` compartilhado e as aplicará aos seus clientes do SDK quando você usar o perfil `localstack`. Usando essa abordagem, seu código não precisa incluir nenhuma referência aos endpoints e teria a seguinte aparência:

```
    // 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);
```

O [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/localstack) está disponível em GitHub.