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.
# Personnalisation du client HTTP
AWS SDK pour Go Utilise un client HTTP par défaut avec des valeurs de configuration par défaut. Bien que vous puissiez modifier certaines de ces valeurs de configuration, le client et le transport HTTP par défaut ne sont pas suffisamment configurés pour les clients utilisant le AWS SDK pour Go dans un environnement présentant des exigences de débit élevé et de faible latence. Pour plus d'informations, reportez-vous au [Questions fréquentes (FAQ)](faq-gosdk.md) car les recommandations de configuration varient en fonction des charges de travail spécifiques. Cette section décrit comment configurer un client HTTP personnalisé et comment utiliser ce client pour créer des AWS SDK pour Go appels.
Pour vous aider à créer un client HTTP personnalisé, cette section décrit comment [NewBuildableClient](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/transport/http#NewBuildableClient)configurer des paramètres personnalisés et comment utiliser ce client avec un client de AWS SDK pour Go service.
Définissons ce que nous voulons personnaliser.
## Remplacement lors du chargement de la configuration
Des clients HTTP personnalisés peuvent être fournis lors d'un appel [LoadDefaultConfig](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#LoadDefaultConfig)en encapsulant le client à l'aide de la HTTPClient touche [With](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#WithHTTP) et en transmettant la valeur résultante à`LoadDefaultConfig`. Par exemple, pour nous faire passer `customClient` pour notre client :
```
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithHTTPClient(customClient))
```
## Expiration
Il `BuildableHTTPClient` peut être configuré avec une limite de délai d'expiration des demandes. Ce délai inclut le temps nécessaire pour se connecter, traiter les redirections et lire le corps de la réponse dans son intégralité. Par exemple, pour modifier le délai d'expiration du client :
```
import "github.com/aws/aws-sdk-go-v2/aws/transport/http"
// ...
httpClient := http.NewBuildableClient().WithTimeout(time.Second*5)
```
## composeur
`BuildableHTTPClient`Il fournit un mécanisme de création pour créer des clients avec des options de [numérotation](https://golang.org/pkg/net/#Dialer) modifiées. L'exemple suivant montre comment configurer les `Dialer` paramètres d'un client.
```
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
})
```
### Paramètres
#### composeur. KeepAlive
Ce paramètre représente la durée de conservation d'une connexion réseau active.
Réglez sur une valeur négative pour désactiver Keep-alives.
Définissez cette valeur sur **0** pour activer Keep-Alives si le protocole et le système d'exploitation le prennent en charge.
Les protocoles réseau ou les systèmes d'exploitation qui ne prennent pas en charge le mode Keep-Alives ignorent ce champ. Par défaut, le protocole TCP active Keep Alive.
Voir [https://golang. org/pkg/net/\$1Dialer. KeepAlive](https://golang.org/pkg/net/#Dialer.KeepAlive)
Définissez `KeepAlive` comme **time.Duration.**
#### Dialer.Timeout
Ce paramètre représente la durée maximale pendant laquelle un cadran attend qu'une connexion soit créée.
La valeur par défaut est de 30 secondes.
Voir [https://golang. org/pkg/net/\$1Dialer .Délai](https://golang.org/pkg/net/#Dialer.Timeout) d'expiration
Définissez `Timeout` comme **time.Duration.**
## Transport
`BuildableHTTPClient`Il fournit un mécanisme de création pour créer des clients avec des options de [transport](https://golang.org/pkg/net/http#Transport) modifiées.
### Configuration d'un proxy
Si vous ne pouvez pas vous connecter directement à Internet, vous pouvez utiliser les variables d'environnement prises en charge par GO (`HTTP_PROXY`/`HTTPS_PROXY`) ou créer un client HTTP personnalisé pour configurer votre proxy. L'exemple suivant configure le client à utiliser `PROXY_URL` comme point de terminaison du 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)
})
```
### Autres paramètres
Vous trouverez ci-dessous quelques autres `Transport` paramètres qui peuvent être modifiés pour régler le client HTTP. Tous les paramètres supplémentaires non décrits ici se trouvent dans la documentation du type de [transport](https://golang.org/pkg/net/http/#Transport). Ces paramètres peuvent être appliqués comme indiqué dans l'exemple suivant :
```
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
Si la demande comporte un en-tête « Expect : 100-continue », ce paramètre représente le temps maximum d'attente pour les premiers en-têtes de réponse d'un serveur après avoir entièrement écrit les en-têtes de demande. Ce délai n'inclut pas le temps d'envoi de l'en-tête de demande. Le client HTTP envoie sa charge utile une fois ce délai expiré.
Par défaut, 1 seconde.
Réglez sur **0** pour éviter tout délai d'expiration et envoyer la charge utile de la demande sans attendre. L'un des cas d'utilisation est celui où vous rencontrez des problèmes avec des proxys ou des services tiers qui prennent une session similaire à l'utilisation d'Amazon S3 dans la fonction illustrée plus loin.
Voir [https://golang. org/pkg/net/http/\$1Transport. ExpectContinueTimeout](https://golang.org/pkg/net/http/#Transport.ExpectContinueTimeout)
Définissez `ExpectContinue` comme **time.Duration.**
#### Transport. IdleConnTimeout
Ce paramètre représente la durée maximale pendant laquelle une connexion réseau inactive est maintenue entre les requêtes HTTP.
Réglez sur **0** pour une limite illimitée.
Voir [https://golang. org/pkg/net/http/\$1Transport. IdleConnTimeout](https://golang.org/pkg/net/http/#Transport.IdleConnTimeout)
Définissez `IdleConnTimeout` comme **time.Duration.**
#### Transport. MaxIdleConns
Ce paramètre représente le nombre maximum de connexions inactives (maintenues actives) sur tous les hôtes. Un cas d'utilisation pour augmenter cette valeur est lorsque vous constatez de nombreuses connexions en peu de temps provenant des mêmes clients
**0** signifie qu'il n'y a pas de limite.
Voir [https://golang. org/pkg/net/http/\$1Transport. MaxIdleConns](https://golang.org/pkg/net/http/#Transport.MaxIdleConns)
`MaxIdleConns`Défini comme **int**.
#### Transport. MaxIdleConnsPerHost
Ce paramètre représente le nombre maximum de connexions inactives (maintenues actives) à conserver par hôte. Un cas d'utilisation pour augmenter cette valeur est lorsque vous constatez de nombreuses connexions en peu de temps provenant des mêmes clients
La valeur par défaut est de deux connexions inactives par hôte.
Réglez sur **0** pour utiliser DefaultMaxIdleConnsPerHost (2).
Voir [https://golang. org/pkg/net/http/\$1Transport. MaxIdleConnsPerHost](https://golang.org/pkg/net/http/#Transport.MaxIdleConnsPerHost)
`MaxIdleConnsPerHost`Défini comme **int**.
#### Transport. ResponseHeaderTimeout
Ce paramètre représente le délai maximal d'attente avant qu'un client lise l'en-tête de réponse.
Si le client n'est pas en mesure de lire l'en-tête de la réponse pendant cette durée, la demande échoue avec une erreur de temporisation.
Veillez à définir cette valeur lorsque vous utilisez des fonctions Lambda de longue durée, car l'opération ne renvoie aucun en-tête de réponse tant que la fonction Lambda n'est pas terminée ou que le délai imparti n'est pas expiré. Cependant, vous pouvez toujours utiliser cette option avec l'opération d'API InvokeAsync \$1\$1 \$1\$1.
Par défaut, il n'y a pas de délai d'attente ; attendez indéfiniment.
Voir [https://golang. org/pkg/net/http/\$1Transport. ResponseHeaderTimeout](https://golang.org/pkg/net/http/#Transport.ResponseHeaderTimeout)
Définissez `ResponseHeaderTimeout` comme **time.Duration.**
#### Transport. TLSHandshakeDélai d'expiration
Ce paramètre représente la durée maximale d'attente avant la fin d'une poignée de main TLS.
La valeur par défaut est de 10 secondes.
Zéro signifie qu'il n'y a aucun délai d'attente.
Voir [https://golang. org/pkg/net/http/\$1Transport. TLSHandshakeDélai d'expiration](https://golang.org/pkg/net/http/#Transport.TLSHandshakeTimeout)
Définissez `TLSHandshakeTimeout` comme **time.Duration.**