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.

# Häufig gestellte Fragen
<a name="faq-gosdk"></a>

## Wie konfiguriere ich den HTTP-Client meines SDK? Gibt es Richtlinien oder bewährte Verfahren?
<a name="how-do-i-configure-my-sdks-http-client-are-there-any-guidelines-or-best-practices"></a>

 Wir sind nicht in der Lage, Kunden zu beraten, wie sie ihren HTTP-Workflow so konfigurieren können, dass sie für ihren speziellen Workload am effektivsten sind. Die Antwort darauf ist das Produkt einer multivariaten Gleichung, zu deren Eingabefaktoren unter anderem gehören, aber nicht darauf beschränkt sind: 
+  die Netzwerkauslastung der Anwendung (TPS, Durchsatz usw.) 
+  die Dienste, die genutzt werden 
+  die Recheneigenschaften der Bereitstellung 
+  der geografische Charakter des Einsatzes 
+  das gewünschte Anwendungsverhalten oder die Anforderungen der Anwendung selbst (SLAs, Zeitpläne usw.) 

## Wie sollte ich Betriebs-Timeouts konfigurieren?
<a name="how-should-i-configure-operation-timeouts"></a>

 Ähnlich wie bei der vorherigen Frage kommt es darauf an. Zu den hier zu berücksichtigenden Elementen gehören die folgenden: 
+  Alle oben genannten Faktoren betreffen die HTTP-Client-Konfiguration 
+  Ihre eigenen Anwendungszeiten oder SLA-Einschränkungen (z. B. wenn Sie selbst Traffic für andere Verbraucher bereitstellen) 

 **Die Antwort auf diese Frage sollte fast NIEMALS auf rein empirischer Beobachtung des Upstream-Verhaltens beruhen** — z. B. „Ich habe 1000 Aufrufe für diesen Vorgang getätigt, er hat höchstens 5 Sekunden gedauert, also werde ich den Timeout auf dieser Grundlage mit einem Sicherheitsfaktor von 2 bis 10 Sekunden festlegen“. Die Umgebungsbedingungen können sich ändern, Dienste können sich vorübergehend verschlechtern, und solche Annahmen können sich ohne Vorwarnung als falsch erweisen. 

## Anfragen des SDK haben eine Zeitüberschreitung oder dauern zu lange. Wie behebe ich das?
<a name="requests-made-by-the-sdk-are-timing-out-or-taking-too-long-how-do-i-fix-this"></a>

 Wir können Ihnen bei längeren Anrufen oder bei Betriebsunterbrechungen nicht weiterhelfen, da wir zu viel Zeit in der Leitung verbracht haben. „Wire Time“ ist im SDK wie folgt definiert: 
+  Für die `HTTPClient.Do()` Methode eines SDK-Clients aufgewendete Zeit 
+  Zeit, die in `Read()` s für einen HTTP-Antworttext verbracht wurde, der an den Aufrufer weitergeleitet wurde (z. B. `GetObject` 

 Wenn Sie aufgrund von Betriebslatenz oder Timeouts Probleme haben, sollten Sie zunächst Telemetriedaten des SDK-Betriebszyklus abrufen, um die zeitliche Trennung zwischen der auf der Leitung verbrachten Zeit und dem damit verbundenen Overhead des Vorgangs zu ermitteln. Weitere Informationen finden Sie im Leitfaden zum [Timing von SDK-Vorgängen](sdk-timing.md), der einen wiederverwendbaren Codeausschnitt enthält, mit dem Sie dies erreichen können. 

## Wie behebe ich einen `read: connection reset` Fehler?
<a name="how-do-i-fix-a-read-connection-reset-error"></a>

 Das SDK wiederholt standardmäßig alle Fehler, die dem `connection reset` Muster entsprechen. Dies deckt die Fehlerbehandlung für die meisten Operationen ab, bei denen die HTTP-Antwort der Operation vollständig verarbeitet und in ihren modellierten Ergebnistyp deserialisiert wird. 

 Dieser Fehler kann jedoch immer noch in einem Kontext **außerhalb** der Wiederholungsschleife auftreten: Bestimmte Dienstoperationen leiten den HTTP-Antworttext der API direkt an den Aufrufer weiter, sodass er direkt über die Leitung abgerufen wird `io.ReadCloser` (z. B. `GetObject` die Objektnutzlast). Dieser Fehler kann auftreten, wenn Sie eine Antwort `Read` auf den Antworttext ausführen. 

 Dieser Fehler weist darauf hin, dass Ihr Host, der Dienst oder eine zwischengeschaltete Partei (z. B. NAT-Gateways, Proxys, Load Balancer) die Verbindung geschlossen hat, während Sie versucht haben, die Antwort zu lesen. 

 Dies kann aus verschiedenen Gründen auftreten: 
+  Sie haben den Antworttext einige Zeit lang nicht verwendet, nachdem die Antwort selbst empfangen wurde (nachdem der Dienstvorgang aufgerufen wurde). **Wir empfehlen Ihnen, den HTTP-Antworttext für diese Art von Vorgängen so schnell wie möglich zu verwenden.** 
+  Sie haben einen zuvor empfangenen Antworttext nicht geschlossen. Dies kann auf bestimmten Plattformen zum Zurücksetzen der Verbindung führen. **Sie MÜSSEN alle `io.ReadCloser` Instanzen schließen, die in der Antwort einer Operation angegeben werden, unabhängig davon, ob Sie deren Inhalt verwenden.** 

 Versuchen Sie außerdem, eine `tcpdump` für eine betroffene Verbindung am Rand Ihres Netzwerks auszuführen (z. B. hinter allen Proxys, die Sie kontrollieren). Wenn Sie feststellen, dass der AWS Endpunkt anscheinend TCP-RST sendet, sollten Sie die AWS Support-Konsole verwenden, um ein Verfahren gegen den betreffenden Dienst einzuleiten. Seien Sie bereit, eine Anfrage IDs und genaue Zeitstempel anzugeben, wann das Problem aufgetreten ist. 

## Warum erhalte ich die Fehlermeldung „Ungültige Signatur“, wenn ich einen HTTP-Proxy mit dem SDK verwende?
<a name="why-am-i-getting-invalid-signature-errors-when-using-an-http-proxy-with-the-sdk"></a>

 Der Signaturalgorithmus für AWS Dienste (im Allgemeinen Sigv4) ist an die Header der serialisierten Anfrage gebunden, genauer gesagt an die meisten Header mit dem Präfix. `X-` Proxys neigen dazu, die ausgehende Anfrage zu modifizieren, indem sie zusätzliche Weiterleitungsinformationen hinzufügen (oft über einen `X-Forwarded-For` Header), wodurch die vom SDK berechnete Signatur effektiv gebrochen wird. 

 Wenn Sie einen HTTP-Proxy verwenden und Signaturfehler auftreten, sollten Sie versuchen, die Anfrage so zu erfassen, **wie sie vom Proxy** ausgeht, und feststellen, ob es sich um eine andere Anfrage handelt. 

# Timing von SDK-Vorgängen
<a name="sdk-timing"></a>

 Beim Debuggen von Timeout-/Latenzproblemen im SDK ist es wichtig, die Komponenten des Betriebslebenszyklus zu identifizieren, deren Ausführung länger dauert als erwartet. Als Ausgangspunkt müssen Sie in der Regel die zeitliche Verteilung zwischen dem gesamten Operationsaufruf und dem HTTP-Aufruf selbst überprüfen. 

 Das folgende Beispielprogramm implementiert eine grundlegende Instrumentierung im Hinblick auf `smithy-go` Middleware für SQS-Clients und demonstriert, wie sie verwendet wird. Die Probe gibt für jeden Operationsaufruf die folgenden Informationen aus: 
+  AWS ID anfordern 
+  Dienst-ID 
+  Name des Vorgangs 
+  Uhrzeit des Aufrufs der Operation 
+  Zeit des HTTP-Anrufs 

 Jeder ausgegebenen Nachricht wird eine eindeutige (für eine einzelne Operation) „Aufruf-ID“ vorangestellt, die am Anfang des Handler-Stacks gesetzt wird. 

 Der Einstiegspunkt für die Instrumentierung wird als bereitgestellt`WithOperationTiming`, der so parametrisiert ist, dass er eine Nachrichtenbehandlungsfunktion akzeptiert, die Instrumentierungs- „Ereignisse“ als formatierte Zeichenketten empfängt. `PrintfMSGHandler`wird aus praktischen Gründen zur Verfügung gestellt, sodass Nachrichten einfach auf die Standardausgabe ausgegeben werden. 

 Der hier verwendete Dienst ist austauschbar - ALLE Service-Client-Optionen akzeptieren `APIOptions` und eine AS-Konfiguration. `HTTPClient` `WithOperationTiming`Könnte zum Beispiel stattdessen wie folgt deklariert werden: 

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

 Wenn Sie es ändern, stellen Sie sicher, dass Sie auch die Signatur der Funktion ändern, die zurückgegeben wird. 

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

 Eine Beispielausgabe dieses Programms: 

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