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

# Domande frequenti
<a name="faq-gosdk"></a>

## Come posso configurare il client HTTP del mio SDK? Esistono linee guida o best practice?
<a name="how-do-i-configure-my-sdks-http-client-are-there-any-guidelines-or-best-practices"></a>

 Non siamo in grado di fornire indicazioni ai clienti su come configurare il flusso di lavoro HTTP nel modo più efficace per il loro particolare carico di lavoro. La risposta a questa domanda è il prodotto di un'equazione multivariata, con fattori di input tra cui, a titolo esemplificativo ma non esaustivo: 
+  l'impronta di rete dell'applicazione (TPS, throughput, ecc.) 
+  i servizi utilizzati 
+  le caratteristiche di calcolo della distribuzione 
+  la natura geografica della distribuzione 
+  il comportamento o le esigenze dell'applicazione stessa desiderati (SLAstempistiche, ecc.) 

## Come devo configurare i timeout operativi?
<a name="how-should-i-configure-operation-timeouts"></a>

 Proprio come la domanda precedente, dipende. Gli elementi da considerare qui includono quanto segue: 
+  Tutti i fattori sopra indicati relativi alla configurazione del client HTTP 
+  vincoli relativi alla tempistica delle applicazioni o agli SLA (ad esempio se sei tu stesso a fornire traffico ad altri consumatori) 

 **La risposta a questa domanda non dovrebbe quasi MAI basarsi sulla pura osservazione empirica del comportamento a monte**, ad esempio «Ho effettuato 1000 chiamate per questa operazione, ci sono voluti al massimo 5 secondi, quindi imposterò il timeout in base a quello con un fattore di sicurezza compreso tra 2 e 10 secondi». Le condizioni ambientali possono cambiare, i servizi possono peggiorare temporaneamente e questi tipi di ipotesi possono diventare errate senza preavviso. 

## Le richieste effettuate dall'SDK scadono o impiegano troppo tempo. Come posso risolvere il problema?
<a name="requests-made-by-the-sdk-are-timing-out-or-taking-too-long-how-do-i-fix-this"></a>

 Non siamo in grado di fornire assistenza in caso di chiamate operative prolungate o scadute a causa del prolungato tempo trascorso in rete. Il «tempo di trasmissione» nell'SDK è definito come uno dei seguenti: 
+  Tempo impiegato nel metodo di un client SDK `HTTPClient.Do()` 
+  Tempo trascorso in `Read()` s su un corpo di risposta HTTP che è stato inoltrato al chiamante (ad es.) `GetObject` 

 In caso di problemi dovuti alla latenza o ai timeout delle operazioni, la prima cosa da fare è ottenere la telemetria del ciclo di vita delle operazioni dell'SDK per determinare la ripartizione temporale tra il tempo trascorso sul cavo e il sovraccarico circostante dell'operazione. Consulta la guida sulla [temporizzazione delle operazioni dell'SDK, che contiene un frammento di codice riutilizzabile per raggiungere](sdk-timing.md) questo obiettivo. 

## Come posso correggere un errore? `read: connection reset`
<a name="how-do-i-fix-a-read-connection-reset-error"></a>

 Per impostazione predefinita, l'SDK riprova qualsiasi errore corrispondente al `connection reset` pattern. Ciò riguarderà la gestione degli errori per la maggior parte delle operazioni, in cui la risposta HTTP dell'operazione viene completamente utilizzata e deserializzata nel tipo di risultato modellato. 

 Tuttavia, questo errore può ancora verificarsi in un contesto **al di fuori** del ciclo di ripetizione: alcune operazioni di servizio inoltrano direttamente il corpo della risposta HTTP dell'API al chiamante per essere utilizzato direttamente dal cavo `io.ReadCloser` (ad esempio`GetObject`, il payload dell'oggetto). È possibile che si verifichi questo errore quando si esegue un comando `Read` sul corpo della risposta. 

 Questo errore indica che l'host, il servizio o qualsiasi intermediario (ad esempio gateway NAT, proxy, sistemi di bilanciamento del carico) ha chiuso la connessione durante il tentativo di leggere la risposta. 

 Questo può verificarsi per diversi motivi: 
+  Il corpo della risposta non è stato utilizzato per qualche tempo dopo la ricezione della risposta stessa (dopo la chiamata dell'operazione di servizio). **Ti consigliamo di utilizzare il corpo della risposta HTTP il prima possibile per questi tipi di operazioni.** 
+  Non hai chiuso un corpo di risposta ricevuto in precedenza. Ciò può causare il ripristino della connessione su determinate piattaforme. **È NECESSARIO chiudere tutte `io.ReadCloser` le istanze fornite nella risposta di un'operazione, indipendentemente dal fatto che se ne utilizzi o meno il contenuto.** 

 Oltre a ciò, prova a eseguire una `tcpdump` connessione interessata ai margini della rete (ad esempio dopo tutti i proxy che controlli). Se notate che l' AWS endpoint sembra inviare un RST TCP, dovreste usare la console di AWS supporto per avviare una causa contro il servizio incriminato. Preparati a fornire richieste IDs e orari specifici in cui si è verificato il problema. 

## Perché ricevo errori di «firma non valida» quando utilizzo un proxy HTTP con l'SDK?
<a name="why-am-i-getting-invalid-signature-errors-when-using-an-http-proxy-with-the-sdk"></a>

 L'algoritmo di firma per AWS i servizi (generalmente sigv4) è legato alle intestazioni della richiesta serializzata, in particolare alla maggior parte delle intestazioni con il prefisso. `X-` I proxy tendono a modificare la richiesta in uscita aggiungendo ulteriori informazioni di inoltro (spesso tramite un'intestazione), il che di fatto infrange la firma calcolata dall'SDK. `X-Forwarded-For` 

 Se utilizzi un proxy HTTP e riscontri errori di firma, dovresti cercare di acquisire la richiesta **così come appare in uscita dal proxy e determinare se è** diversa. 

# Timing delle operazioni SDK
<a name="sdk-timing"></a>

 Quando si eseguono il debug di problemi di timeout/latenza nell'SDK, è fondamentale identificare i componenti del ciclo di vita dell'operazione che richiedono più tempo del previsto per l'esecuzione. Come punto di partenza, in genere è necessario esaminare la ripartizione temporale tra la chiamata operativa complessiva e la chiamata HTTP stessa. 

 Il seguente programma di esempio implementa una sonda di strumentazione di base in termini di `smithy-go` middleware per i client SQS e ne dimostra l'utilizzo. La sonda emette le seguenti informazioni per ogni chiamata operativa: 
+  AWS ID della richiesta 
+  ID del servizio 
+  nome dell'operazione 
+  tempo di invocazione dell'operazione 
+  tempo di chiamata http 

 Ogni messaggio emesso è preceduto da un «ID di invocazione» univoco (per una singola operazione) impostato all'inizio dello stack del gestore. 

 Il punto di ingresso per la strumentazione è esposto come`WithOperationTiming`, che è parametrizzato per accettare una funzione di gestione dei messaggi che riceverà gli «eventi» della strumentazione come stringhe formattate. `PrintfMSGHandler`è fornito per comodità e consente semplicemente di scaricare i messaggi su stdout. 

 Il servizio qui utilizzato è intercambiabile: TUTTE le opzioni del client di servizio sono accettate `APIOptions` e vengono visualizzate come configurazione. `HTTPClient` Ad esempio, `WithOperationTiming` potrebbe invece essere dichiarato come: 

```
func WithOperationTiming(msgHandler func(string)) func(*s3.Options)
func WithOperationTiming(msgHandler func(string)) func(*dynamodb.Options)
// etc.
```

 Se lo modifichi, assicurati di cambiare anche la firma della funzione che restituisce. 

```
import (
    "context"
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"

    awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
    awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/sqs"
    "github.com/aws/smithy-go/middleware"
    smithyrand "github.com/aws/smithy-go/rand"
)

// WithOperationTiming instruments an SQS client to dump timing information for
// the following spans:
//   - overall operation time
//   - HTTPClient call time
//
// This instrumentation will also emit the request ID, service name, and
// operation name for each invocation.
//
// Accepts a message "handler" which is invoked with formatted messages to be
// handled externally, you can use the declared PrintfMSGHandler to simply dump
// these values to stdout.
func WithOperationTiming(msgHandler func(string)) func(*sqs.Options) {
    return func(o *sqs.Options) {
        o.APIOptions = append(o.APIOptions, addTimingMiddlewares(msgHandler))
        o.HTTPClient = &timedHTTPClient{
            client:     awshttp.NewBuildableClient(),
            msgHandler: msgHandler,
        }
    }
}

// PrintfMSGHandler writes messages to stdout.
func PrintfMSGHandler(msg string) {
    fmt.Printf("%s\n", msg)
}

type invokeIDKey struct{}

func setInvokeID(ctx context.Context, id string) context.Context {
    return middleware.WithStackValue(ctx, invokeIDKey{}, id)
}

func getInvokeID(ctx context.Context) string {
    id, _ := middleware.GetStackValue(ctx, invokeIDKey{}).(string)
    return id
}

// Records the current time, and returns a function to be called when the
// target span of events is completed. The return function will emit the given
// span name and time elapsed to the given message consumer.
func timeSpan(ctx context.Context, name string, consumer func(string)) func() {
    start := time.Now()
    return func() {
        elapsed := time.Now().Sub(start)
        consumer(fmt.Sprintf("[%s] %s: %s", getInvokeID(ctx), name, elapsed))
    }
}

type timedHTTPClient struct {
    client     *awshttp.BuildableClient
    msgHandler func(string)
}

func (c *timedHTTPClient) Do(r *http.Request) (*http.Response, error) {
    defer timeSpan(r.Context(), "http", c.msgHandler)()

    resp, err := c.client.Do(r)
    if err != nil {
        return nil, fmt.Errorf("inner client do: %v", err)
    }

    return resp, nil
}

type addInvokeIDMiddleware struct {
    msgHandler func(string)
}

func (*addInvokeIDMiddleware) ID() string { return "addInvokeID" }

func (*addInvokeIDMiddleware) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    out middleware.InitializeOutput, md middleware.Metadata, err error,
) {
    id, err := smithyrand.NewUUID(smithyrand.Reader).GetUUID()
    if err != nil {
        return out, md, fmt.Errorf("new uuid: %v", err)
    }

    return next.HandleInitialize(setInvokeID(ctx, id), in)
}

type timeOperationMiddleware struct {
    msgHandler func(string)
}

func (*timeOperationMiddleware) ID() string { return "timeOperation" }

func (m *timeOperationMiddleware) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    middleware.InitializeOutput, middleware.Metadata, error,
) {
    defer timeSpan(ctx, "operation", m.msgHandler)()
    return next.HandleInitialize(ctx, in)
}

type emitMetadataMiddleware struct {
    msgHandler func(string)
}

func (*emitMetadataMiddleware) ID() string { return "emitMetadata" }

func (m *emitMetadataMiddleware) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
    middleware.InitializeOutput, middleware.Metadata, error,
) {
    out, md, err := next.HandleInitialize(ctx, in)

    invokeID := getInvokeID(ctx)
    requestID, _ := awsmiddleware.GetRequestIDMetadata(md)
    service := awsmiddleware.GetServiceID(ctx)
    operation := awsmiddleware.GetOperationName(ctx)
    m.msgHandler(fmt.Sprintf(`[%s] requestID = "%s"`, invokeID, requestID))
    m.msgHandler(fmt.Sprintf(`[%s] service   = "%s"`, invokeID, service))
    m.msgHandler(fmt.Sprintf(`[%s] operation = "%s"`, invokeID, operation))

    return out, md, err
}

func addTimingMiddlewares(mh func(string)) func(*middleware.Stack) error {
    return func(s *middleware.Stack) error {
        if err := s.Initialize.Add(&timeOperationMiddleware{msgHandler: mh}, middleware.Before); err != nil {
            return fmt.Errorf("add time operation middleware: %v", err)
        }
        if err := s.Initialize.Add(&addInvokeIDMiddleware{msgHandler: mh}, middleware.Before); err != nil {
            return fmt.Errorf("add invoke id middleware: %v", err)
        }
        if err := s.Initialize.Insert(&emitMetadataMiddleware{msgHandler: mh}, "RegisterServiceMetadata", middleware.After); err != nil {
            return fmt.Errorf("add emit metadata middleware: %v", err)
        }
        return nil
    }
}

func main() {
    cfg, err := config.LoadDefaultConfig(context.Background())
    if err != nil {
        log.Fatal(fmt.Errorf("load default config: %v", err))
    }

    svc := sqs.NewFromConfig(cfg, WithOperationTiming(PrintfMSGHandler))

    var wg sync.WaitGroup

    for i := 0; i < 6; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()

            _, err = svc.ListQueues(context.Background(), nil)
            if err != nil {
                fmt.Println(fmt.Errorf("list queues: %v", err))
            }
        }()
    }
    wg.Wait()
}
```

 Un esempio di output di questo programma: 

```
[e9a801bb-c51d-45c8-8e9f-a202e263fde8] http: 192.24067ms
[e9a801bb-c51d-45c8-8e9f-a202e263fde8] requestID = "dbee3082-96a3-5b23-adca-6d005696fa94"
[e9a801bb-c51d-45c8-8e9f-a202e263fde8] service   = "SQS"
[e9a801bb-c51d-45c8-8e9f-a202e263fde8] operation = "ListQueues"
[e9a801bb-c51d-45c8-8e9f-a202e263fde8] operation: 193.098393ms
[0740f0e0-953e-4328-94fc-830a5052e763] http: 195.185732ms
[0740f0e0-953e-4328-94fc-830a5052e763] requestID = "48b301fa-fc9f-5f1f-9007-5c783caa9322"
[0740f0e0-953e-4328-94fc-830a5052e763] service   = "SQS"
[0740f0e0-953e-4328-94fc-830a5052e763] operation = "ListQueues"
[0740f0e0-953e-4328-94fc-830a5052e763] operation: 195.725491ms
[c0589832-f351-4cc7-84f1-c656eb79dbd7] http: 200.52383ms
[444030d0-6743-4de5-bd91-bc40b2b94c55] http: 200.525919ms
[c0589832-f351-4cc7-84f1-c656eb79dbd7] requestID = "4a73cc82-b47b-56e1-b327-9100744e1b1f"
[c0589832-f351-4cc7-84f1-c656eb79dbd7] service   = "SQS"
[c0589832-f351-4cc7-84f1-c656eb79dbd7] operation = "ListQueues"
[c0589832-f351-4cc7-84f1-c656eb79dbd7] operation: 201.214365ms
[444030d0-6743-4de5-bd91-bc40b2b94c55] requestID = "ca1523ed-1879-5610-bf5d-7e6fd84cabee"
[444030d0-6743-4de5-bd91-bc40b2b94c55] service   = "SQS"
[444030d0-6743-4de5-bd91-bc40b2b94c55] operation = "ListQueues"
[444030d0-6743-4de5-bd91-bc40b2b94c55] operation: 201.197071ms
[079e8dbd-bb93-43ab-89e5-a7bb392b86a5] http: 206.449568ms
[12b2b39d-df86-4648-a436-ff0482d13340] http: 206.526603ms
[079e8dbd-bb93-43ab-89e5-a7bb392b86a5] requestID = "64229710-b552-56ed-8f96-ca927567ec7b"
[079e8dbd-bb93-43ab-89e5-a7bb392b86a5] service   = "SQS"
[079e8dbd-bb93-43ab-89e5-a7bb392b86a5] operation = "ListQueues"
[079e8dbd-bb93-43ab-89e5-a7bb392b86a5] operation: 207.252357ms
[12b2b39d-df86-4648-a436-ff0482d13340] requestID = "76d9cbc0-07aa-58aa-98b7-9642c79f9851"
[12b2b39d-df86-4648-a436-ff0482d13340] service   = "SQS"
[12b2b39d-df86-4648-a436-ff0482d13340] operation = "ListQueues"
[12b2b39d-df86-4648-a436-ff0482d13340] operation: 207.360621ms
```