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.

# Gestion des erreurs dans la AWS SDK pour Go V2
<a name="handle-errors"></a>

 Les erreurs de AWS SDK pour Go retour qui répondent au type `error` d'interface Go. Vous pouvez utiliser `Error()` cette méthode pour obtenir une chaîne formatée du message d'erreur du SDK sans aucune manipulation particulière. Les erreurs renvoyées par le SDK peuvent implémenter une `Unwrap` méthode. La `Unwrap` méthode est utilisée par le SDK pour fournir des informations contextuelles supplémentaires sur les erreurs, tout en donnant accès à l'erreur sous-jacente ou à la chaîne d'erreurs. La `Unwrap` méthode doit être utilisée avec [Errors.as pour gérer le déballage](https://golang.org/pkg/errors#As) des chaînes d'erreurs. 

 Il est important que votre application vérifie si une erreur s'est produite après avoir invoqué une fonction ou une méthode capable de renvoyer un type d'`error`interface. La forme la plus élémentaire de gestion des erreurs ressemble à l'exemple suivant : 

```
if err != nil {
    // Handle error
    return
}
```

## Erreurs de journalisation
<a name="logging-errors"></a>

 La forme la plus simple de gestion des erreurs consiste généralement à consigner ou à imprimer le message d'erreur avant de revenir ou de quitter l'application. 

```
import "log"

// ...

if err != nil {
    log.Printf("error: %s", err.Error())
    return
}
```

## Erreurs du client de service
<a name="service-client-errors"></a>

 [Le SDK intègre toutes les erreurs renvoyées par les clients du service à la forge. OperationError](https://pkg.go.dev/github.com/aws/smithy-go#OperationError)type d'erreur. `OperationError`fournit des informations contextuelles sur le nom du service et le fonctionnement associés à une erreur sous-jacente. Ces informations peuvent être utiles pour les applications qui exécutent des opérations par lots sur un ou plusieurs services, grâce à un mécanisme centralisé de gestion des erreurs. Votre application peut accéder `errors.As` à ces `OperationError` métadonnées. 

```
import "log"
import "github.com/aws/smithy-go"

// ...

if err != nil {
    var oe *smithy.OperationError
    if errors.As(err, &oe) {
        log.Printf("failed to call service: %s, operation: %s, error: %v", oe.Service(), oe.Operation(), oe.Unwrap())
    }
    return
}
```

### Réponses aux erreurs de l'API
<a name="api-error-responses"></a>

 Les opérations de service peuvent renvoyer des types d'erreur modélisés pour indiquer des erreurs spécifiques. Ces types modélisés peuvent être utilisés `errors.As` pour déballer et déterminer si l'échec du fonctionnement est dû à une erreur spécifique. Par exemple, Amazon S3 `CreateBucket` peut renvoyer une [BucketAlreadyExists](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#BucketAlreadyExists)erreur si un compartiment du même nom existe déjà. 

 Par exemple, pour vérifier si une erreur était une `BucketAlreadyExists` erreur : 

```
import "log"
import "github.com/aws/aws-sdk-go-v2/service/s3/types"

// ...

if err != nil {
    var bne *types.BucketAlreadyExists
    if errors.As(err, &bne) {
        log.Println("error:", bne)
    }
    return
}
```

 Toutes les erreurs de réponse de l'API de service implémentent le [Smithy. APIError](https://pkg.go.dev/github.com/aws/smithy-go/#APIError)type d'interface. Cette interface peut être utilisée pour gérer les réponses d'erreur de service modélisées ou non modélisées. Ce type permet d'accéder au code d'erreur et au message renvoyés par le service. De plus, ce type indique si l'erreur est due au client ou au serveur, s'il est connu. 

```
import "log"
import "github.com/aws/smithy-go"

// ...

if err != nil {
    var ae smithy.APIError
    if errors.As(err, &ae) {
        log.Printf("code: %s, message: %s, fault: %s", ae.ErrorCode(), ae.ErrorMessage(), ae.ErrorFault().String())
    }
    return
}
```

## Récupération des identifiants de demande
<a name="retrieving-request-identifiers"></a>

 Lorsque vous travaillez avec le AWS Support, il peut vous être demandé de fournir l'identifiant de demande qui identifie la demande que vous tentez de résoudre. Vous pouvez utiliser [http. ResponseError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/transport/http#ResponseError)et utilisez la `ServiceRequestID()` méthode pour récupérer l'identifiant de demande associé à la réponse d'erreur. 

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

// ...

if err != nil {
    var re *awshttp.ResponseError
    if errors.As(err, &re) {
        log.Printf("requestID: %s, error: %v", re.ServiceRequestID(), re.Unwrap());
    }
    return
}
```

### Identifiants de demande Amazon S3
<a name="s3-request-identifiers"></a>

 Les demandes Amazon S3 contiennent des identifiants supplémentaires qui peuvent être utilisés pour aider le AWS Support à résoudre votre demande. Vous pouvez utiliser [s3. ResponseError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#ResponseError)et appelez `ServiceRequestID()` et `ServiceHostID()` pour récupérer l'ID de demande et l'ID d'hôte. 

```
import "log"
import "github.com/aws/aws-sdk-go-v2/service/s3"

// ...

if err != nil {
    var re s3.ResponseError
    if errors.As(err, &re) {
        log.Printf("requestID: %s, hostID: %s request failure", re.ServiceRequestID(), re.ServiceHostID());
    }
    return
}
```