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.

# Mit dem AWS SDK für Go
<a name="using"></a>

Lernen Sie gängige und empfohlene Methoden zur Programmierung mit dem AWS SDK für Go in Ihren Anwendungen kennen.

**Topics**
+ [Einen Service-Client erstellen](#constructing-a-service-client)
+ [Service Operations aufrufen](#calling-service-operations)
+ [Gleichzeitige Verwendung von Service-Clients](#concurrently-using-service-clients)
+ [Verwendung von Operation Paginators](#using-operation-paginators)
+ [Verwenden von Waiter-Objekten](#using-waiters)
+ [Behandlung von Fehlern im SDK](handle-errors.md)

## Einen Service-Client erstellen
<a name="constructing-a-service-client"></a>

 Service-Clients können entweder mithilfe der `NewFromConfig` Funktionen `New` oder erstellt werden, die im Go-Paket des Service-Clients verfügbar sind. Jede Funktion gibt einen `Client` Strukturtyp zurück, der die Methoden zum Aufrufen des Dienstes APIs enthält. `NewFromConfig`Beide bieten dieselben konfigurierbaren Optionen für die Erstellung eines Service-Clients, bieten jedoch leicht unterschiedliche Konstruktionsmuster, die wir in den folgenden Abschnitten betrachten werden. `New` 

### NewFromConfig
<a name="newfromconfig"></a>

 `NewFromConfig`[Die Funktion bietet eine konsistente Schnittstelle für die Erstellung von Service-Clients mithilfe von AWS.config.](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#Config) [Eine `aws.Config` kann mit der Konfiguration geladen werden. LoadDefaultConfig](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/config#LoadDefaultConfig). Weitere Informationen zum Konstruieren eines finden Sie `aws.Config` unter[Das SDKs konfigurieren](configure-gosdk.md). Das folgende Beispiel zeigt, wie ein Amazon S3 S3-Serviceclient mit der `NewFromConfig` Funktion `aws.Config` und erstellt wird: 

```
import "context"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        panic(err)
    }
    
    client := s3.NewFromConfig(cfg)
```

#### Konfiguration überschreiben
<a name="overriding-configuration"></a>

 `NewFromConfig`kann ein oder mehrere funktionale Argumente annehmen, die die `Options` Konfigurationsstruktur eines Clients verändern können. Auf diese Weise können Sie bestimmte Überschreibungen vornehmen, z. B. die Region ändern oder dienstspezifische Optionen wie die Amazon S3 `UseAccelerate` S3-Option ändern. Zum Beispiel: 

```
import "context"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        panic(err)
    }
    
    client := s3.NewFromConfig(cfg, func(o *s3.Options) {
        o.Region = "us-west-2"
        o.UseAccelerate = true
    })
```

 Das Überschreiben des `Options` Client-Werts hängt von der Reihenfolge ab, in der die Funktionsargumente angegeben werden. `NewFromConfig` 

### Neu
<a name="new"></a>

**Anmerkung**  
 `New`wird als eine fortgeschrittenere Form der Client-Konstruktion angesehen. Wir empfehlen die Verwendung `NewFromConfig` für die Konstruktion auf Kundenbasis, da es die Konstruktion unter Verwendung der `aws.Config` Struktur ermöglicht. Dadurch entfällt die Notwendigkeit, für jeden Service-Client, den Ihre Anwendung benötigt, eine `Options` Strukturinstanz zu erstellen. 

 `New`Die Funktion ist ein Client-Konstruktor, der eine Schnittstelle zum Konstruieren von Clients bereitstellt, wobei nur die `Options` Struktur des Client-Pakets verwendet wird, um die Konfigurationsoptionen des Clients zu definieren. Um beispielsweise einen Amazon S3 S3-Client zu erstellen mit`New`: 

```
import "github.com/aws/aws-sdk-go-v2/aws"
    import "github.com/aws/aws-sdk-go-v2/credentials"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    
    // ...
    
    client := s3.New(s3.Options{
        Region:      "us-west-2",
        Credentials: aws.NewCredentialsCache(credentials.NewStaticCredentialsProvider(accessKey, secretKey, "")),
    })
```

#### Konfiguration überschreiben
<a name="overriding-configuration-1"></a>

 `New`kann ein oder mehrere funktionale Argumente annehmen, die die `Options` Konfigurationsstruktur eines Clients verändern können. Auf diese Weise können Sie bestimmte Überschreibungen vornehmen, z. B. die Region ändern oder dienstspezifische Optionen wie die Amazon S3 `UseAccelerate` S3-Option ändern. Zum Beispiel: 

```
import "github.com/aws/aws-sdk-go-v2/aws"
    import "github.com/aws/aws-sdk-go-v2/credentials"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    
    // ...
    
    options := s3.Options{
        Region:      "us-west-2",
        Credentials: aws.NewCredentialsCache(credentials.NewStaticCredentialsProvider(accessKey, secretKey, "")),
    }
    
    client := s3.New(options, func(o *s3.Options) {
        o.Region = "us-east-1"
        o.UseAccelerate = true
    })
```

 Das Überschreiben des `Options` Client-Werts hängt von der Reihenfolge ab, in der die Funktionsargumente angegeben werden. `New` 

## Service Operations aufrufen
<a name="calling-service-operations"></a>

 Nachdem Sie eine Service-Client-Instanz eingerichtet haben, können Sie sie verwenden, um die Operationen eines Dienstes aufzurufen. Um beispielsweise den Amazon S3 `GetObject` S3-Vorgang aufzurufen: 

```
response, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
        Bucket: aws.String("amzn-s3-demo-bucket"),
        Key:    aws.String("obj-key"),
    })
```

 Wenn Sie einen Servicevorgang aufrufen, validiert das SDK synchron die Eingabe, serialisiert die Anfrage, signiert sie mit Ihren Anmeldeinformationen, sendet sie an AWS und deserialisiert dann eine Antwort oder einen Fehler. In den meisten Fällen können Sie Service Operations direkt aufrufen. Jede Client-Methode für Dienstoperationen gibt eine Operationsantwort-Struktur und einen Fehlerschnittstellentyp zurück. Sie sollten immer den `error` Typ überprüfen, um festzustellen, ob ein Fehler aufgetreten ist, bevor Sie versuchen, auf die Antwortstruktur der Serviceoperation zuzugreifen. 

### Übergabe von Parametern an einen Dienstvorgang
<a name="passing-parameters-to-a-service-operation"></a>

 Jede Dienstvorgangsmethode verwendet einen [Context.Context-Wert](https://golang.org/pkg/context/#Context), der zur Festlegung von Anforderungsfristen verwendet werden kann, die vom SDK eingehalten werden. Darüber hinaus verwendet jeder Dienstvorgang eine `<OperationName>Input` Struktur, die sich im jeweiligen Go-Paket des Dienstes befindet. Sie übergeben API-Eingabeparameter mithilfe der Eingabestruktur der Operation. 

 Eingabestrukturen für Operationen können Eingabeparameter wie die Standardtypen Go-Numerik, Boolean, String, Map und List haben. Bei komplexeren API-Vorgängen kann ein Dienst eine komplexere Modellierung von Eingabeparametern aufweisen. Diese anderen Typen, wie z. B. dienstspezifische Strukturen und Aufzählungswerte, sind im `types` Go-Paket des Dienstes enthalten. 

 Darüber hinaus können Dienste zwischen dem Standardwert eines Go-Typs und der Frage, ob der Wert vom Benutzer festgelegt wurde oder nicht, unterscheiden. In diesen Fällen müssen Sie für Eingabeparameter möglicherweise eine Zeigerreferenz auf den betreffenden Typ übergeben. Für Standard-Go-Typen wie Numerik, Boolean und String stehen `<Type>` in der [AWS `From<Type>`](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws) praktische Funktionen zur Verfügung, um diese Konvertierung zu vereinfachen. [AWS.String](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#String) kann beispielsweise verwendet werden, um a in einen `*string` Typ für Eingabeparameter `string` zu konvertieren, die einen Zeiger auf eine Zeichenfolge erfordern. [Umgekehrt, aws. ToString](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws#ToString)kann verwendet werden, um a in a `*string` zu transformieren `string` und schützt so vor der Dereferenzierung eines Nullzeigers. Die `To<Type>` Funktionen sind hilfreich bei der Bearbeitung von Serviceantworten. 

 Schauen wir uns ein Beispiel an, wie wir einen Amazon S3 S3-Client verwenden können, um die `GetObject` API aufzurufen, und unsere Eingabe mithilfe des `types` Pakets und der `aws.<Type>` Helfer erstellen können. 

```
import "context"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    import "github.com/aws/aws-sdk-go-v2/service/s3/types"
    
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        panic(err)
    }
    
    client := s3.NewFromConfig(cfg)
    
    resp, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
        Bucket:       aws.String("amzn-s3-demo-bucket"),
        Key:          aws.String("keyName"),
        RequestPayer: types.RequestPayerRequester,
    })
```

### Client-Optionen für Operation Call überschreiben
<a name="overriding-client-options"></a>

 Ähnlich wie Client-Betriebsoptionen während der Erstellung eines Clients mithilfe von funktionalen Argumenten geändert werden können, können die Client-Optionen beim Aufruf der Operationsmethode geändert werden, indem der Service-Operationsmethode ein oder mehrere funktionale Argumente zur Verfügung gestellt werden. Diese Aktion ist parallelitätssicher und wirkt sich nicht auf andere gleichzeitige Operationen auf dem Client aus. 

 Um beispielsweise die Client-Region von „us-west-2" auf „us-east-1" zu überschreiben: 

```
cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
    if err != nil {
        log.Printf("error: %v", err)
        return
    }
    
    client := s3.NewFromConfig(cfg)
    
    params := &s3.GetObjectInput{
        // ...
    }
    
    resp, err := client.GetObject(context.TODO(), params, func(o *Options) {
        o.Region = "us-east-1"
    })
```

### Umgang mit Betriebsantworten
<a name="handling-operation-responses"></a>

 Jeder Dienstoperation ist eine Ausgabestruktur zugeordnet, die die Operation-Response-Elemente des Dienstes enthält. Die Ausgabestruktur folgt dem folgenden Benennungsmuster`<OperationName>Output`. Bei einigen Operationen sind möglicherweise keine Mitglieder für ihre Operationsausgabe definiert. Nach dem Aufrufen einer Dienstoperation sollte der Typ des `error` Rückgabearguments immer überprüft werden, um festzustellen, ob beim Aufrufen der Dienstoperation ein Fehler aufgetreten ist. Die zurückgegebenen Fehler können von Fehlern bei der clientseitigen Eingabeüberprüfung bis hin zu dienstseitigen Fehlerantworten reichen, die an den Client zurückgegeben werden. Auf die Ausgabestruktur der Operation sollte nicht zugegriffen werden, falls der Client einen Fehler zurückgibt, der ungleich Null ist. 

 Um beispielsweise einen Operationsfehler zu protokollieren und vorzeitig von der aufrufenden Funktion zurückzukehren: 

```
response, err := client.GetObject(context.TODO())
    if err != nil {
        log.Printf("GetObject error: %v", err)
        return
    }
```

 Weitere Informationen zur Fehlerbehandlung, einschließlich der Suche nach bestimmten Fehlertypen, finden Sie unter TODO 

#### Antworten mit `io.ReadCloser`
<a name="responses-with-ioreadcloser"></a>

 Einige API-Operationen geben eine Antwortstruktur zurück, die ein Ausgabeelement enthält, bei dem es sich um einen handelt`io.ReadCloser`. Dies wird bei API-Operationen der Fall sein, bei denen ein Teil ihrer Ausgabe im Hauptteil der HTTP-Antwort selbst verfügbar gemacht wird. 

 Beispielsweise gibt der Amazon S3 `GetObject` S3-Vorgang eine Antwort zurück, deren `Body` Mitglied ein `io.ReadCloser` für den Zugriff auf die Objektnutzlast ist. 

**Warnung**  
 Sie MÜSSEN IMMER `Close()` beliebige `io.ReadCloser` Output-Elemente angeben, unabhängig davon, ob Sie den Inhalt konsumiert haben. Geschieht dies nicht, können Ressourcen verloren gehen und es kann zu Problemen beim Lesen der Antwortstellen für Operationen führen, die in future einberufen werden. 

```
resp, err := s3svc.GetObject(context.TODO(), &s3.GetObjectInput{...})
    if err != nil {
        // handle error
        return
    }
    // Make sure to always close the response Body when finished
    defer resp.Body.Close()
    
    decoder := json.NewDecoder(resp.Body)
    if err := decoder.Decode(&myStruct); err != nil {
        // handle error
        return
    }
```

#### Metadaten der Antwort
<a name="response-metadata"></a>

 Alle Ausgabestrukturen für Dienstoperationen enthalten ein `ResultMetadata` Element des Typs [Middleware.Metadata](https://pkg.go.dev/github.com/aws/smithy-go/middleware#Metadata). `middleware.Metadata`wird von der SDK-Middleware verwendet, um zusätzliche Informationen aus einer Dienstantwort bereitzustellen, die nicht vom Dienst modelliert wird. Dazu gehören Metadaten wie die. `RequestID` Um beispielsweise die mit einer Serviceanfrage `RequestID` verknüpfte Antwort abzurufen, um den AWS Support bei der Behebung einer Anfrage zu unterstützen: 

```
import "fmt"
    import "log"
    import "github.com/aws/aws-sdk-go-v2/aws/middleware"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    
    // ..
    
    resp, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
        // ...
    })
    if err != nil {
        log.Printf("error: %v", err)
        return
    }
    
    requestID, ok := middleware.GetRequestIDMetadata(resp.ResultMetadata)
    if !ok {
        fmt.Println("RequestID not included with request")
    }
    
    fmt.Printf("RequestID: %s\n", requestID)
```

## Gleichzeitige Verwendung von Service-Clients
<a name="concurrently-using-service-clients"></a>

 Sie können Goroutinen erstellen, die denselben Service-Client gleichzeitig verwenden, um mehrere Anfragen zu senden. Sie können einen Service-Client mit so vielen Goroutinen verwenden, wie Sie möchten. 

 Im folgenden Beispiel wird ein Amazon S3 S3-Serviceclient in mehreren Goroutinen verwendet. In diesem Beispiel werden zwei Objekte gleichzeitig in einen Amazon S3 S3-Bucket hochgeladen. 

```
import "context"
    import "log"
    import "strings"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        log.Printf("error: %v", err)
        return
    }
    
    client := s3.NewFromConfig(cfg)
    
    type result struct {
        Output *s3.PutObjectOutput
        Err    error
    }
    
    results := make(chan result, 2)
    
    var wg sync.WaitGroup
    wg.Add(2)
    
    go func() {
    defer wg.Done()
        output, err := client.PutObject(context.TODO(), &s3.PutObjectInput{
            Bucket: aws.String("amzn-s3-demo-bucket"),
            Key:    aws.String("foo"),
            Body:   strings.NewReader("foo body content"),
        })
        results <- result{Output: output, Err: err}
    }()
    
    go func() {
        defer wg.Done()
        output, err := client.PutObject(context.TODO(), &s3.PutObjectInput{
            Bucket: aws.String("amzn-s3-demo-bucket"),
            Key:    aws.String("bar"),
            Body:   strings.NewReader("bar body content"),
        })
        results <- result{Output: output, Err: err}
    }()
    
    wg.Wait()
    
    close(results)
    
    for result := range results {
        if result.Err != nil {
            log.Printf("error: %v", result.Err)
            continue
        }
        fmt.Printf("etag: %v", aws.ToString(result.Output.ETag))
    }
```

## Verwendung von Operation Paginators
<a name="using-operation-paginators"></a>

 Wenn Sie eine Liste von Elementen abrufen, müssen Sie in der Regel in der Ausgabestruktur nach einem Token oder einer Markierung suchen, um zu überprüfen, ob der AWS Dienst alle Ergebnisse Ihrer Anfrage zurückgegeben hat. Wenn das Token oder die Markierung vorhanden ist, verwenden Sie sie, um die nächste Ergebnisseite anzufordern. Anstatt diese Token oder Markierungen zu verwalten, können Sie die verfügbaren Paginatortypen des Servicepakets verwenden. 

 Paginator-Helfer sind für unterstützte Serviceoperationen verfügbar und befinden sich im Go-Paket des Service-Clients. Verwenden Sie die Funktion, um einen Paginator für eine unterstützte Operation zu erstellen. `New<OperationName>Paginator` Paginator-Konstruktfunktionen verwenden den Dienst`Client`, die `<OperationName>Input` Eingabeparameter der Operation und einen optionalen Satz von Funktionsargumenten, mit denen Sie weitere optionale Paginatoreinstellungen konfigurieren können. 

 Der Paginatortyp für zurückgegebene Operationen bietet eine bequeme Möglichkeit, über eine paginierte Operation zu iterieren, bis Sie die letzte Seite erreicht haben oder die Elemente gefunden haben, nach denen Ihre Anwendung gesucht hat. Ein Paginatortyp hat zwei Methoden: und. `HasMorePages` `NextPage` `HasMorePages`gibt einen booleschen Wert zurück, `true` wenn die erste Seite nicht abgerufen wurde oder ob weitere Seiten verfügbar sind, die mit der Operation abgerufen werden können. Um die ersten oder die nachfolgenden Seiten der Operation abzurufen, muss die `NextPage` Operation aufgerufen werden. `NextPage`nimmt die Operationsausgabe `context.Context` und alle entsprechenden Fehler auf und gibt sie zurück. Wie bei den Rückgabeparametern der Client-Operationsmethode sollte der Rückgabefehler immer überprüft werden, bevor versucht wird, die zurückgegebene Antwortstruktur zu verwenden. Siehe [Umgang mit Betriebsantworten](#handling-operation-responses). 

 Im folgenden Beispiel wird der `ListObjectsV2` Paginator verwendet, um bis zu drei Seiten mit Objektschlüsseln aus der `ListObjectV2` Operation aufzulisten. Jede Seite besteht aus bis zu 10 Schlüsseln, was durch die `Limit` Paginator-Option definiert wird. 

```
import "context"
    import "log"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/aws"
    import "github.com/aws/aws-sdk-go-v2/service/s3"
    
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        log.Printf("error: %v", err)
        return
    }
    
    client := s3.NewFromConfig(cfg)
    
    params := &s3.ListObjectsV2Input{
        Bucket: aws.String("amzn-s3-demo-bucket"),
    }
    
    paginator := s3.NewListObjectsV2Paginator(client, params, func(o *s3.ListObjectsV2PaginatorOptions) {
        o.Limit = 10
    })
    
    pageNum := 0
    for paginator.HasMorePages() && pageNum < 3 {
        output, err := paginator.NextPage(context.TODO())
        if err != nil {
            log.Printf("error: %v", err)
            return
        }
        for _, value := range output.Contents {
            fmt.Println(*value.Key)
        }
        pageNum++
    }
```

 Ähnlich wie bei der Client-Betriebsmethode können die Client-Optionen wie die Anforderungsregion geändert werden, indem ein oder mehrere funktionale Argumente für angegeben werden. `NextPage` Weitere Hinweise zum Überschreiben von Client-Optionen beim Aufrufen einer Operation finden Sie unter[Client-Optionen für Operation Call überschreiben](#overriding-client-options). 

## Verwenden von Waiter-Objekten
<a name="using-waiters"></a>

 Bei der asynchronen Interaktion mit AWS APIs diesen Ressourcen müssen Sie oft warten, bis eine bestimmte Ressource verfügbar ist, um weitere Aktionen darauf ausführen zu können. 

 Beispielsweise kehrt die Amazon DynamoDB `CreateTable` DynamoDB-API sofort mit dem Wert CREATING TableStatus zurück, und Sie können keine Lese- oder Schreiboperationen aufrufen, bis der Tabellenstatus auf den Tabellenstatus umgestellt wurde. `ACTIVE` 

 Das Schreiben von Logik zur kontinuierlichen Abfrage des Tabellenstatus kann umständlich und fehleranfällig sein. Die Kellner helfen dabei, die Komplexität zu verringern, und sind einfach und erledigen APIs die Abfrageaufgabe für Sie. 

 Sie können beispielsweise waiters verwenden, um abzufragen, ob eine DynamoDB-Tabelle erstellt wurde und für einen Schreibvorgang bereit ist. 

```
import "context"
    import "fmt"
    import "log"
    import "time"
    import "github.com/aws/aws-sdk-go-v2/aws"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        log.Printf("error: %v", err)
        return
    }
    
    client := dynamodb.NewFromConfig(cfg)
    
    // we create a waiter instance by directly passing in a client
    // that satisfies the waiters client Interface. 
    waiter :=  dynamodb.NewTableExistsWaiter(client)
    
    // params is the input to api operation used by the waiter
    params := &dynamodb.DescribeTableInput {
        TableName: aws.String("test-table")
    }
    
    // maxWaitTime is the maximum wait time, the waiter will wait for 
    // the resource status.
    maxWaitTime := 5 * time.Minutes
    
    // Wait will poll until it gets the resource status, or max wait time 
    // expires.
    err := waiter.Wait(context.TODO(), params, maxWaitTime)  
    if err != nil {
        log.Printf("error: %v", err)
        return 
    }
    fmt.Println("Dynamodb table is now ready for write operations")
```

### Die Kellner-Konfiguration wird außer Kraft gesetzt
<a name="overriding-waiter-configuration"></a>

 Standardmäßig verwendet das SDK die Werte für die minimale Verzögerung und die maximale Verzögerung, die mit den optimalen Werten konfiguriert sind, die von den AWS Diensten für verschiedene Dienste definiert werden. APIs Sie können die Kellnerkonfiguration überschreiben, indem Sie beim Aufbau des Kellners oder beim Aufrufen eines Kellnervorgangs Funktionsoptionen angeben. 

 Zum Beispiel, um die Kellnerkonfiguration während der Installation des Kellners zu überschreiben 

```
import "context"
    import "fmt"
    import "log"
    import "time"
    import "github.com/aws/aws-sdk-go-v2/aws"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        log.Printf("error: %v", err)
        return
    }
    
    client := dynamodb.NewFromConfig(cfg)
    
    // we create a waiter instance by directly passing in a client
    // that satisfies the waiters client Interface. 
    waiter :=  dynamodb.NewTableExistsWaiter(client, func (o *dynamodb.TableExistsWaiterOptions) {
        
        // override minimum delay to 10 seconds
        o.MinDelay = 10 * time.Second
        
        // override maximum default delay to 300 seconds
        o.MaxDelay = 300 * time.Second
    })
```

Die `Wait` Funktion für jeden Kellner umfasst auch funktionale Optionen. Ähnlich wie im obigen Beispiel können Sie die Kellnerkonfiguration pro `Wait` Anfrage überschreiben.

```
// params is the input to api operation used by the waiter
    params := &dynamodb.DescribeTableInput {
        TableName: aws.String("test-table")
    }
    
    // maxWaitTime is the maximum wait time, the waiter will wait for 
    // the resource status.
    maxWaitTime := 5 * time.Minutes
    
    // Wait will poll until it gets the resource status, or max wait time 
    // expires.
    err := waiter.Wait(context.TODO(), params, maxWaitTime, func (o *dynamodb.TableExistsWaiterOptions) {
    
        // override minimum delay to 5 seconds
        o.MinDelay = 5 * time.Second
    
        // override maximum default delay to 120 seconds
        o.MaxDelay = 120 * time.Second
    })
    if err != nil {
        log.Printf("error: %v", err)
        return 
    }
    fmt.Println("Dynamodb table is now ready for write operations")
```

### Die erweiterte Kellnerkonfiguration hat Vorrang
<a name="advanced-waiter-configuration-overrides"></a>

 Sie können das Standardverhalten des Kellners zusätzlich anpassen, indem Sie eine benutzerdefinierte Wiederholungsfunktion bereitstellen. [Die kellnerspezifischen Optionen ermöglichen auch die Anpassung von Betriebs-Middlewares. `APIOptions`](middleware.md#writing-a-custom-middleware) 

 Zum Beispiel, um erweiterte Einstellungen für Kellner zu konfigurieren. 

```
import "context"
    import "fmt"
    import "log"
    import "time"
    import "github.com/aws/aws-sdk-go-v2/aws"
    import "github.com/aws/aws-sdk-go-v2/config"
    import "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    import "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
    // ...
    
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        log.Printf("error: %v", err)
        return
    }
    
    client := dynamodb.NewFromConfig(cfg)
    
    // custom retryable defines if a waiter state is retryable or a terminal state.
    // For example purposes, we will configure the waiter to not wait 
    // if table status is returned as `UPDATING`
    customRetryable := func(ctx context.Context, params *dynamodb.DescribeTableInput, 
        output *dynamodb.DescribeTableOutput, err error) (bool, error) {
        if output.Table != nil {
            if output.Table.TableStatus == types.TableStatusUpdating {
                // if table status is `UPDATING`, no need to wait
                return false, nil   
            }
        }
    }
    
    // we create a waiter instance by directly passing in a client
    // that satisfies the waiters client Interface. 
    waiter :=  dynamodb.NewTableExistsWaiter(client, func (o *dynamodb.TableExistsWaiterOptions) {
        
        // override the service defined waiter-behavior
        o.Retryable = customRetryable
    })
```