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

# Personalizar o cliente HTTP
<a name="configure-http"></a>

 O AWS SDK para Go usa um cliente HTTP padrão com valores de configuração padrão. Embora você possa alterar alguns desses valores de configuração, o transporte e o cliente HTTP padrão não estão suficientemente configurados para clientes que o usam AWS SDK para Go em um ambiente com requisitos de alto throughput e baixa latência. Consulte mais informações em [Perguntas frequentes](faq-gosdk.md), já que as recomendações de configuração variam com base em workloads específicas. Esta seção descreve como configurar um cliente HTTP personalizado e usar esse cliente para criar chamadas do AWS SDK para Go. 

 Para ajudar a criar um cliente HTTP personalizado, esta seção descreve como usar [NewBuildableClient](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/transport/http#NewBuildableClient) para definir configurações personalizadas e usar esse cliente com um cliente de serviço do AWS SDK para Go. 

 Vamos definir o que queremos personalizar. 

## Substituição durante o carregamento da configuração
<a name="overriding-during-configuration-loading"></a>

 Clientes HTTP personalizados podem ser fornecidos ao chamar [LoadDefaultConfig](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#LoadDefaultConfig) encapsulando o cliente usando [WithHTTPClient](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#WithHTTP) e passando o valor resultante para `LoadDefaultConfig`. Por exemplo, para passar `customClient` como nosso cliente: 

```
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithHTTPClient(customClient))
```

## Tempo limite
<a name="timeout"></a>

 O `BuildableHTTPClient` pode ser configurado com um limite de tempo limite de solicitação. Esse tempo limite inclui o tempo para se conectar, processar qualquer redirecionamento e ler o corpo completo da resposta. Por exemplo, para modificar o tempo limite do cliente: 

```
import "github.com/aws/aws-sdk-go-v2/aws/transport/http"

// ...

httpClient := http.NewBuildableClient().WithTimeout(time.Second*5)
```

## Dialer
<a name="dialer"></a>

 O `BuildableHTTPClient` fornece uma mecânica de compilador para construir clientes com opções modificadas do [Dialer](https://golang.org/pkg/net/#Dialer). O exemplo a seguir mostra como definir as configurações de `Dialer` de um cliente. 

```
import awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
import "net"

// ...

httpClient := awshttp.NewBuildableClient().WithDialerOptions(func(d *net.Dialer) {
    d.KeepAlive = -1
    d.Timeout = time.Millisecond*500
})
```

### Configurações
<a name="settings"></a>

#### Dialer.KeepAlive
<a name="dialerkeepalive"></a>

 Essa configuração representa o período de keep-alive de uma conexão de rede ativa. 

 Defina como um valor negativo para desativar os keep-alives. 

 Defina como **0** para ativar o keep-alives, se compatível com o protocolo e o sistema operacional. 

 Protocolos de rede ou sistemas operacionais que não são compatíveis com keep-alives ignoram esse campo. Por padrão, o TCP ativa o keep-alive. 

 Consulte [https://golang.org/pkg/net/\$1Dialer.KeepAlive](https://golang.org/pkg/net/#Dialer.KeepAlive) 

 Defina `KeepAlive` como **time.Duration**. 

#### Dialer.Timeout
<a name="dialertimeout"></a>

 Essa configuração representa o tempo máximo que um dial espera pela criação de uma conexão. 

 O padrão é 30 segundos. 

 Consulte [https://golang.org/pkg/net/\$1Dialer.Timeout](https://golang.org/pkg/net/#Dialer.Timeout) 

 Defina `Timeout` como **time.Duration**. 

## Transport
<a name="transport"></a>

 O `BuildableHTTPClient` fornece uma mecânica de compilador para construir clientes com opções modificadas de [Transport](https://golang.org/pkg/net/http#Transport). 

### Configurar um proxy
<a name="configuring-a-proxy"></a>

 Se não conseguir se conectar diretamente à internet, você poderá usar variáveis de ambiente compatíveis com Go (`HTTP_PROXY`/`HTTPS_PROXY`) ou criar um cliente HTTP personalizado para configurar o proxy. O exemplo a seguir configura o cliente para usar `PROXY_URL` como endpoint do proxy: 

```
import awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
import "net/http"

// ...

httpClient := awshttp.NewBuildableClient().WithTransportOptions(func(tr *http.Transport) {
    proxyURL, err := url.Parse("PROXY_URL")
    if err != nil {
        log.Fatal(err)
    }
    tr.Proxy = http.ProxyURL(proxyURL)
})
```

### Outras configurações
<a name="other-settings"></a>

 Veja a seguir algumas outras configurações de `Transport` que podem ser modificadas para ajustar o cliente HTTP. Qualquer configuração adicional não descrita aqui pode ser encontrada na documentação do tipo de [Transport](https://golang.org/pkg/net/http/#Transport). Essas configurações podem ser aplicadas conforme mostrado no exemplo a seguir: 

```
import awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
import "net/http"

// ...

httpClient := awshttp.NewBuildableClient().WithTransportOptions(func(tr *http.Transport) {
    tr.ExpectContinueTimeout = 0
    tr.MaxIdleConns = 10
})
```

#### Transport.ExpectContinueTimeout
<a name="transportexpectcontinuetimeout"></a>

 Se a solicitação tiver um cabeçalho “Expect: 100-continue”, essa configuração representa o tempo máximo de espera pelos cabeçalhos da primeira resposta de um servidor após a gravação completa dos cabeçalhos da solicitação. Esse tempo não inclui o tempo para enviar o cabeçalho da solicitação. O cliente HTTP envia sua carga útil depois que esse tempo limite se esgota. 

 Padrão de 1 segundo. 

 Defina como **0** para desabilitar o tempo limite e enviar a carga útil da solicitação sem esperar. Um caso de uso é quando você se depara com problemas com proxies ou serviços de terceiros que realizam uma sessão semelhante ao uso do Amazon S3 na função mostrada posteriormente. 

 Consulte [https://golang.org/pkg/net/http/\$1Transport.ExpectContinueTimeout](https://golang.org/pkg/net/http/#Transport.ExpectContinueTimeout) 

 Defina `ExpectContinue` como **time.Duration**. 

#### Transport.IdleConnTimeout
<a name="transportidleconntimeout"></a>

 Essa configuração representa o tempo máximo para manter uma conexão de rede ociosa ativa entre as solicitações HTTP. 

 Defina como **0** para desabilitar o limite. 

 Consulte [https://golang.org/pkg/net/http/\$1Transport.IdleConnTimeout](https://golang.org/pkg/net/http/#Transport.IdleConnTimeout) 

 Defina `IdleConnTimeout` como **time.Duration**. 

#### Transport.MaxIdleConns
<a name="transportmaxidleconns"></a>

 Essa configuração representa o número máximo de conexões ociosas (keep-alive) em todos os hosts. Um caso de uso para aumentar esse valor é quando você vê muitas conexões dos mesmos clientes em um curto período. 

 **0** significa que não há limite. 

 Consulte [https://golang.org/pkg/net/http/\$1Transport.MaxIdleConns](https://golang.org/pkg/net/http/#Transport.MaxIdleConns) 

 Defina `MaxIdleConns` como **int**. 

#### Transport.MaxIdleConnsPerHost
<a name="transportmaxidleconnsperhost"></a>

 Essa configuração representa o número máximo de conexões ociosas (keep-alive) a serem mantidas por host. Um caso de uso para aumentar esse valor é quando você vê muitas conexões dos mesmos clientes em um curto período. 

 O padrão é duas conexões ociosas por host. 

 Defina como **0** para usar DefaultMaxIdleConnsPerHost (2). 

 Consulte [https://golang.org/pkg/net/http/\$1Transport.MaxIdleConnsPerHost](https://golang.org/pkg/net/http/#Transport.MaxIdleConnsPerHost) 

 Defina `MaxIdleConnsPerHost` como **int**. 

#### Transport.ResponseHeaderTimeout
<a name="transportresponseheadertimeout"></a>

 Essa configuração representa o tempo máximo de espera para que um cliente leia o cabeçalho de resposta. 

 Se o cliente não conseguir ler o cabeçalho da resposta dentro desse período, a solicitação falhará com um erro de tempo limite. 

 Tenha cuidado ao definir esse valor ao usar funções do Lambda de longa duração, pois a operação não retorna nenhum cabeçalho de resposta até que a função do Lambda tenha terminado ou atingido o tempo limite. No entanto, você ainda pode usar essa opção com a operação da API \$1\$1 InvokeAsync\$1\$1. 

 O padrão é sem tempo limite; esperar indefinidamente. 

 Consulte [https://golang.org/pkg/net/http/\$1Transport.ResponseHeaderTimeout](https://golang.org/pkg/net/http/#Transport.ResponseHeaderTimeout) 

 Defina `ResponseHeaderTimeout` como **time.Duration**. 

#### Transport.TLSHandshakeTimeout
<a name="transporttlshandshaketimeout"></a>

 Essa configuração representa o tempo máximo de espera pela conclusão de um handshake TLS. 

 O padrão é 10 segundos. 

 Zero significa que não há tempo limite. 

 Consulte [https://golang.org/pkg/net/http/\$1Transport.TLSHandshakeTimeout](https://golang.org/pkg/net/http/#Transport.TLSHandshakeTimeout) 

 Defina `TLSHandshakeTimeout` como **time.Duration**.