Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Gestione degli errori nella AWS SDK per Go V2
<a name="handle-errors"></a>

 AWS SDK per Go Restituisce errori che soddisfano il tipo di `error` interfaccia Go. È possibile utilizzare il `Error()` metodo per ottenere una stringa formattata del messaggio di errore SDK senza alcuna gestione speciale. Gli errori restituiti dall'SDK possono implementare un metodo. `Unwrap` Il `Unwrap` metodo viene utilizzato dall'SDK per fornire informazioni contestuali aggiuntive sugli errori, fornendo al contempo l'accesso all'errore o alla catena di errori sottostante. Il `Unwrap` metodo deve essere usato con [Errors.as per gestire l'unwrapping](https://golang.org/pkg/errors#As) delle catene di errori. 

 È importante che l'applicazione verifichi se si è verificato un errore dopo aver richiamato una funzione o un metodo in grado di restituire un tipo di interfaccia. `error` La forma più semplice di gestione degli errori è simile al seguente esempio: 

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

## Errori di registrazione
<a name="logging-errors"></a>

 La forma più semplice di gestione degli errori consiste tradizionalmente nel registrare o stampare il messaggio di errore prima di tornare o uscire dall'applicazione. 

```
import "log"

// ...

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

## Errori del client di servizio
<a name="service-client-errors"></a>

 [L'SDK include tutti gli errori restituiti dai client di servizio con la fucina. OperationError](https://pkg.go.dev/github.com/aws/smithy-go#OperationError)tipo di errore. `OperationError`fornisce informazioni contestuali sul nome e sull'operazione del servizio associati a un errore sottostante. Queste informazioni possono essere utili per le applicazioni che eseguono batch di operazioni su uno o più servizi, con un meccanismo centralizzato di gestione degli errori. L'applicazione può utilizzare `errors.As` per accedere a questi `OperationError` metadati. 

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

### Risposte di errore API
<a name="api-error-responses"></a>

 Le operazioni di servizio possono restituire tipi di errore modellati per indicare errori specifici. Questi tipi modellati possono essere utilizzati con `errors.As` per decomprimere e determinare se l'errore dell'operazione è dovuto a un errore specifico. Ad esempio, Amazon S3 `CreateBucket` può restituire un [BucketAlreadyExists](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3/types#BucketAlreadyExists)errore se esiste già un bucket con lo stesso nome. 

 Ad esempio, per verificare se un errore era un `BucketAlreadyExists` errore: 

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

 Tutti gli errori di risposta dell'API di servizio implementano la [fucina. APIError](https://pkg.go.dev/github.com/aws/smithy-go/#APIError)tipo di interfaccia. Questa interfaccia può essere utilizzata per gestire risposte di errore di servizio sia modellate che non modellate. Questo tipo fornisce l'accesso al codice di errore e al messaggio restituiti dal servizio. Inoltre, questo tipo indica se l'errore è dovuto al client o al server, se noto. 

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

## Recupero degli identificatori della richiesta
<a name="retrieving-request-identifiers"></a>

 Quando si collabora con AWS Support, è possibile che venga richiesto di fornire l'identificatore della richiesta che identifica la richiesta che si sta tentando di risolvere. [Puoi usare http. ResponseError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/transport/http#ResponseError)e usa il `ServiceRequestID()` metodo per recuperare l'identificatore della richiesta associato alla risposta all'errore. 

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

### Identificatori di richiesta Amazon S3
<a name="s3-request-identifiers"></a>

 Le richieste Amazon S3 contengono identificatori aggiuntivi che possono essere utilizzati per assistere il AWS Supporto nella risoluzione dei problemi della richiesta. [Puoi usare s3. ResponseError](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#ResponseError)e chiama `ServiceRequestID()` e `ServiceHostID()` recupera l'ID della richiesta e l'ID dell'host. 

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