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á.

# Configuração de endpoints de cliente no AWS SDK for Java 2.x
<a name="endpoint-config"></a>

O SDK para Java 2.x fornece várias maneiras de configurar os endpoints de serviço. Um endpoint é o URL que o SDK usa para fazer chamadas de API para Serviços da AWS. Por padrão, o SDK determina automaticamente o endpoint apropriado para cada serviço com base na Região da AWS que você configurou. No entanto, há cenários em que talvez seja necessário personalizar ou substituir esses endpoints: 
+ Ao trabalhar com implementações de serviços locais ou de terceiros (como LocalStack)
+ Ao conectar-se com o Serviços da AWS por meio de um proxy ou endpoint da VPC
+ Ao fazer testes em endpoints de serviços beta ou de pré-lançamento

## Opções de configuração do endpoint
<a name="endpoint-configuration-options"></a>

 O AWS SDK for Java 2.x oferece várias maneiras de configurar endpoints: 
+ Configuração no código usando o compilador do cliente de serviço
+ Configuração externa com variáveis de ambiente
+ Configuração externa com propriedades do sistema de JVM
+ Configuração externa com arquivo de configuração compartilhado da AWS

## Configuração do endpoint no código
<a name="in-code-endpoint-configuration"></a>

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

 A forma mais direta de configurar um endpoint é usando o método `endpointOverride` no compilador do cliente de serviço. Esse método aceita um objeto `URI` que representa o URL personalizado do endpoint. 

**Example Definir um endpoint personalizado para um cliente do 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();
```

Ao usar o `endpointOverride`, você ainda deve especificar uma região para o cliente, mesmo que o endpoint esteja sendo definido explicitamente. A região é usada para assinar solicitações. 

### Descoberta de endpoint
<a name="endpoint-discovery"></a>

Alguns Serviços da AWS permitem descoberta de endpoints, em que o SDK pode descobrir automaticamente o endpoint ideal a ser usado. É possível habilitar ou desabilitar esse recurso usando o método `endpointDiscoveryEnabled` no compilador do cliente de serviço. 

**Example Habilitar a descoberta de endpoints para um cliente do 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();
```

## Configuração do endpoint no nível de solicitação
<a name="request-level-endpoint-configuration"></a>

Em alguns casos, talvez seja necessário substituir o endpoint de uma solicitação específica enquanto usa o mesmo cliente para outras solicitações com o endpoint padrão. O AWS SDK for Java 2.x viabiliza isso por meio de substituições de solicitações. 

**Example Substituir o endpoint para uma solicitação específica**  

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

Observe que as substituições de endpoint no nível da solicitação são limitadas e podem não funcionar em todos os serviços ou cenários. Na maioria dos casos, é recomendável usar a configuração do endpoint no nível do cliente. 

## Configuração de endpoint externa
<a name="external-endpoint-configuration"></a>

### Usar variáveis de ambiente
<a name="environment-variables-for-endpoints"></a>

É possível configurar endpoints usando variáveis de ambiente. O SDK permite a configuração do endpoint específico do serviço por meio de variáveis de ambiente no formato `AWS_ENDPOINT_URL_[SERVICE]`, em que `[SERVICE]` é o identificador de serviço em maiúsculas. 

**Example Configurar um endpoint do S3 usando variáveis de ambiente**  

```
# 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
```

 Você também pode definir um prefixo ou sufixo de URL de endpoint global usando as seguintes variáveis de ambiente: 
+ `AWS_ENDPOINT_URL`: define um endpoint global para todos os serviços
+ `AWS_ENDPOINT_URL_PREFIX`: adiciona um prefixo a todos os endpoints de serviço
+ `AWS_ENDPOINT_URL_SUFFIX`: adiciona um sufixo a todos os endpoints de serviço

### Usar as propriedades do sistema de JVM
<a name="jvm-system-properties-for-endpoints"></a>

 Você também pode configurar endpoints usando as propriedades do sistema de JVM. O formato é semelhante às variáveis de ambiente, mas usa uma convenção de nomenclatura diferente. 

**Example Configurar um endpoint do S3 usando as propriedades do sistema de JVM**  

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

 A configuração do endpoint global também está disponível por meio das propriedades do sistema: 
+ `aws.endpointUrl`: define um endpoint global para todos os serviços
+ `aws.endpointUrl.prefix`: adiciona um prefixo a todos os endpoints de serviço
+ `aws.endpointUrl.suffix`: adiciona um sufixo a todos os endpoints de serviço

### Usar o arquivo de configuração compartilhado da AWS
<a name="aws-config-file-for-endpoints"></a>

 O AWS SDK for Java 2.x também permite a configuração do endpoint por meio do arquivo de configuração compartilhado da AWS, normalmente localizado em `~/.aws/config` (Linux/macOS) ou `%USERPROFILE%\.aws\config` (Windows). Consulte informações e exemplos no [Guia de referência de AWS SDKs e ferramentas](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html#ss-endpoints-config).

## Precedência de configuração
<a name="endpoint-configuration-precedence"></a>

 Quando várias configurações do endpoint estão presentes, o SDK segue essa ordem de precedência (da maior para a menor): 

1. Substituições no nível da solicitação (quando aplicável)

1. Configuração no nível do cliente via `endpointOverride`

1. Variáveis de ambiente

1. Propriedade do sistema de JVM

1. Arquivo de configuração compartilhado da AWS

1. Endpoints padrão com base na Região da AWS configurada

## Configuração do endpoint específico do serviço
<a name="service-specific-endpoint-configuration"></a>

 Alguns Serviços da AWS têm opções adicionais de configuração do endpoint específicas desse serviço. Veja a seguir alguns exemplos: 

### Configurações do endpoint do Amazon S3
<a name="s3-endpoint-configuration"></a>

 O Amazon S3 permite várias configurações do endpoint por meio da classe `S3Configuration`: 
+ `dualstackEnabled`: habilita o suporte a IPv6
+ `accelerateModeEnabled`: habilita a Aceleração de Transferências do S3.
+ `pathStyleAccessEnabled`: usa acesso no estilo de caminho em vez do estilo hospedado virtualmente
+ `useArnRegionEnabled`: usa a região de um ARN para solicitações entre regiões
+ `fipsModeEnabled`: encaminha solicitações para endpoints compatíveis com FIPS

**Example Configurar opções de endpoint específicas do 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();
```

### Configuração do endpoint do DynamoDB
<a name="dynamodb-endpoint-configuration"></a>

 Para o DynamoDB, talvez você queira usar a descoberta de endpoints ou conectar-se ao [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) local para testes: 

**Example Conectar-se ao DynamoDB 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();
```

O DynamoDB também permite o uso [de endpoints baseados em contas](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html), que você pode configurar no código ou usando configurações externas. O exemplo a seguir mostra como desabilitar o uso de endpoints baseados em conta no código ao criar o cliente (as configurações padrão são *preferenciais*):

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

## Práticas recomendadas
<a name="endpoint-configuration-best-practices"></a>

 Ao configurar endpoints no AWS SDK for Java 2.x, considere estas práticas recomendadas: 
+  *Use a configuração externa para endpoints específicos do ambiente*: use variáveis de ambiente, propriedades do sistema ou o arquivo de configuração AWS para endpoints que variam entre ambientes (desenvolvimento, teste, produção). 
+  *Use a configuração no código para endpoints específicos da aplicação*: use o método `endpointOverride` do compilador do cliente para endpoints específicos do design da aplicação. 
+  *Sempre especifique uma região*: mesmo ao substituir endpoints, sempre especifique uma região conforme ela é usada para assinatura de solicitações. 
+  *Tenha cuidado com substituições globais de endpoints*: usar substituições globais de endpoints pode afetar todos os serviços, o que pode não ser o que você pretende. 
+  *Considere as implicações de segurança*: ao usar endpoints personalizados, eles devem ter medidas de segurança adequadas, especialmente para workloads de produção.