Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Umgang mit Fehlern in der AWS SDK für Go V2
<a name="handle-errors"></a>

 Die AWS SDK für Go Rückgabefehler, die dem `error` Go-Schnittstellentyp entsprechen. Sie können die `Error()` Methode verwenden, um eine formatierte Zeichenfolge der SDK-Fehlermeldung ohne besondere Behandlung abzurufen. Fehler, die vom SDK zurückgegeben werden, können eine `Unwrap` Methode implementieren. Die `Unwrap` Methode wird vom SDK verwendet, um zusätzliche Kontextinformationen zu Fehlern bereitzustellen und gleichzeitig Zugriff auf den zugrunde liegenden Fehler oder die Fehlerkette zu erhalten. Die `Unwrap` Methode sollte zusammen mit [Errors.as verwendet werden, um das Entpacken von Fehlerketten](https://golang.org/pkg/errors#As) zu behandeln. 

 Es ist wichtig, dass Ihre Anwendung überprüft, ob nach dem Aufrufen einer Funktion oder Methode, die einen Schnittstellentyp zurückgeben kann, ein Fehler aufgetreten ist. `error` Die einfachste Form der Fehlerbehandlung ähnelt dem folgenden Beispiel: 

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

## Fehler protokollieren
<a name="logging-errors"></a>

 Die einfachste Form der Fehlerbehandlung besteht traditionell darin, die Fehlermeldung zu protokollieren oder auszudrucken, bevor Sie zur Anwendung zurückkehren oder sie verlassen. 

```
import "log"

// ...

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

## Fehler beim Service Client
<a name="service-client-errors"></a>

 Das SDK fasst alle von Service Clients zurückgegebenen Fehler mit dem [Smithy zusammen. OperationError](https://pkg.go.dev/github.com/aws/smithy-go#OperationError)Art des Fehlers. `OperationError`stellt kontextbezogene Informationen über den Dienstnamen und den Vorgang bereit, der mit einem zugrunde liegenden Fehler verknüpft ist. Diese Informationen können für Anwendungen nützlich sein, die stapelweise Operationen für einen oder mehrere Dienste ausführen und über einen zentralen Fehlerbehandlungsmechanismus verfügen. Ihre Anwendung kann für den Zugriff `errors.As` auf diese `OperationError` Metadaten verwendet werden. 

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

### Antworten auf API-Fehler
<a name="api-error-responses"></a>

 Serviceoperationen können modellierte Fehlertypen zurückgeben, um auf bestimmte Fehler hinzuweisen. Diese modellierten Typen können verwendet werden`errors.As`, um herauszufinden, ob der Ausfall des Vorgangs auf einen bestimmten Fehler zurückzuführen ist. Amazon S3 `CreateBucket` kann beispielsweise einen [BucketAlreadyExists](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#BucketAlreadyExists)Fehler zurückgeben, wenn bereits ein Bucket mit demselben Namen existiert. 

 Um beispielsweise zu überprüfen, ob ein Fehler ein `BucketAlreadyExists` Fehler war: 

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

 Alle Antwortfehler der Service-API implementieren den [Smithy. APIError](https://pkg.go.dev/github.com/aws/smithy-go/#APIError)Schnittstellentyp. Diese Schnittstelle kann verwendet werden, um sowohl modellierte als auch nicht modellierte Servicefehlerantworten zu verarbeiten. Dieser Typ ermöglicht den Zugriff auf den Fehlercode und die vom Dienst zurückgegebene Meldung. Darüber hinaus gibt dieser Typ an, ob der Fehler auf den Client oder Server zurückzuführen ist, sofern bekannt. 

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

## Anforderungskennungen werden abgerufen
<a name="retrieving-request-identifiers"></a>

 Wenn Sie mit dem AWS Support zusammenarbeiten, werden Sie möglicherweise aufgefordert, die Anfrage-ID anzugeben, die die Anfrage identifiziert, die Sie zu beheben versuchen. Sie können [http verwenden. ResponseError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/transport/http#ResponseError)und verwenden Sie die `ServiceRequestID()` Methode, um die Anforderungskennung abzurufen, die der Fehlerantwort zugeordnet ist. 

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

### Amazon S3 S3-Anforderungskennungen
<a name="s3-request-identifiers"></a>

 Amazon S3 S3-Anfragen enthalten zusätzliche Identifikatoren, die verwendet werden können, um den AWS Support bei der Behebung Ihrer Anfrage zu unterstützen. Sie können [s3 verwenden. ResponseError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#ResponseError)und rufen Sie an `ServiceRequestID()` und `ServiceHostID()` um die Anfrage-ID und die Host-ID abzurufen. 

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