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.

# DAX SDK für Go
<a name="DAX.client.run-application-go-2"></a>

Gehen Sie wie folgt vor, um die Amazon-DynamoDB-Accelerator-(DAX)-SDK für Go auf Ihrer Amazon-EC2-Instance auszuführen.

**So führen Sie das SDK-für-Go-Beispiel für DAX aus**

1. Richten Sie das SDK für Go auf Ihrer Amazon-EC2-Instance ein:

   1. Installieren Sie die Go-Programmiersprache (`Golang`).

      ```
      sudo yum install -y golang
      ```

   1. Testen Sie, ob Golang installiert ist und ordnungsgemäß ausgeführt wird.

      ```
      go version
      ```

      Eine Nachricht wie diese sollte erscheinen.

      ```
      go version go1.23.4 linux/amd64
      ```

1. Installieren Sie die Golang-Beispielanwendung.

   ```
   go get github.com/aws-samples/sample-aws-dax-go-v2
   ```

1. Führen Sie die folgenden Golang-Programme aus. Das erste Programm erstellt eine DynamoDB-Tabelle mit dem Namen `TryDaxGoTable`. Das zweite Programm schreibt Daten in die Tabelle.

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dynamodb -command create-table
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dynamodb -command put-item
   ```

1. Führen Sie die folgenden Golang-Programme aus.

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dynamodb -command get-item
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dynamodb -command query
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dynamodb -command scan
   ```

   Beachten Sie die Zeitinformationen – die Anzahl der benötigten Millisekunden für den `GetItem`-, `Query`- und `Scan`-Test.

1. Im vorherigen Schritt haben Sie die Programme für den DynamoDB-Endpunkt ausgeführt. Führen Sie die Programme jetzt erneut aus. Dieses Mal werden die `GetItem`-, `Query`- und `Scan`-Operationen aber vom DAX-Cluster verarbeitet.

   Um den Endpunkt für Ihren DAX-Cluster zu bestimmen, wählen Sie einen der folgenden Schritte aus:
   + **Using the DynamoDB console** (Verwenden der DynamoDB-Konsole) — Wählen Sie Ihren DAX-Cluster aus. Der Cluster-Endpunkt wird auf der Konsole angezeigt, wie im folgenden Beispiel gezeigt.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Verwenden von AWS CLI— Geben Sie den** folgenden Befehl ein.

     ```
     aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
     ```

     Der Cluster-Endpunkt wird wie im folgenden Beispiel in der Ausgabe angezeigt.

     ```
     {
         "Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
         "Port": 8111,
         "URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
     }
     ```

   Führen Sie jetzt die Programme erneut aus. Geben Sie dieses Mal jedoch den Cluster-Endpunkt als Befehlszeilenparameter an.

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dax -command get-item -endpoint my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com:8111
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dax -command query -endpoint my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com:8111
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dax -command scan -endpoint my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com:8111
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dax -command paginated-scan -endpoint my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com:8111
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dax -command paginated-query -endpoint my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com:8111
   ```

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dax -command paginated-batch-get -endpoint my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com:8111
   ```

   Sehen Sie sich den Rest der Ausgabe an und notieren Sie die Zeitinformationen. Die verstrichene Zeit sollte für `GetItem`, `Query` und `Scan` mit DAX deutlich kürzer sein als mit DynamoDB.

1. Führen Sie das folgende Golang-Programm aus, um `TryDaxGoTable` zu löschen:

   ```
   go run ~/go/pkg/mod/github.com/aws-samples/sample-aws-dax-go-v2@v1.0.0/try_dax.go -service dynamodb -command delete-table
   ```

## Funktionen, die nicht gleichwertig sind mit AWS SDK für Go V2
<a name="DAX.client.run-application-go-features-not-in-parity"></a>

Middleware-Stack: DAX Go V2 unterstützt die Verwendung von Middleware-Stacks über APIoptions nicht. Weitere Informationen finden Sie unter [Anpassen der AWS SDK für Go v2-Client-Anfragen mit](https://docs.aws.amazon.com/sdk-for-go/v2/developer-guide/middleware.html#:~:text=You%20can%20customize%20AWS%20SDK,step's%20input%20and%20output%20types) Middleware.

Beispiel:

```
// Custom middleware implementation
type customSerializeMiddleware struct{}
// ID returns the identifier for the middleware
func (m *customSerializeMiddleware) ID() string {
    return "CustomMiddleware"
}
// HandleSerialize implements the serialize middleware handler
func (m *customSerializeMiddleware) HandleSerialize(
    ctx context.Context,
    in middleware.SerializeInput,
    next middleware.SerializeHandler,
) (
    out middleware.SerializeOutput,
    metadata middleware.Metadata,
    err error,
) {
    // Add your custom logic here before the request is serialized
    fmt.Printf("Executing custom middleware for request: %v\n", in)
    // Call the next handler in the middleware chain
    return next.HandleSerialize(ctx, in)
}

func executeGetItem(ctx context.Context) error {
    client, err := initItemClient(ctx)
    if err != nil {
        os.Stderr.WriteString(fmt.Sprintf("failed to initialize client: %v\n", err))
        return err
    }

    st := time.Now()
    for c := 0; c < iterations; c++ {
        for i := 0; i < pkMax; i++ {
            for j := 0; j < skMax; j++ {
                // Create key using attributevalue.Marshal for type safety
                pk, err := attributevalue.Marshal(fmt.Sprintf("%s_%d", keyPrefix, i))
                if err != nil {
                    return fmt.Errorf("error marshaling pk: %v", err)
                }
                sk, err := attributevalue.Marshal(fmt.Sprintf("%d", j))
                if err != nil {
                    return fmt.Errorf("error marshaling sk: %v", err)
                }
                key := map[string]types.AttributeValue{
                    "pk": pk,
                    "sk": sk,
                }
                in := &dynamodb.GetItemInput{
                    TableName: aws.String(table),
                    Key:       key,
                }

                // Custom middleware option
                customMiddleware := func(o *dynamodb.Options) {
                    o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error {
                        // Add custom middleware to the stack
                        return stack.Serialize.Add(&customSerializeMiddleware{}, middleware.After)
                    })
                }

                // Apply options to the GetItem call
                out, err := client.GetItem(ctx, in, customMiddleware)
                if err != nil {
                    return err
                }
                writeVerbose(out)
            }
        }
    }
    d := time.Since(st)
    os.Stdout.WriteString(fmt.Sprintf("Total Time: %v, Avg Time: %v\n", d, d/iterations))
    return nil
}
```

Ausgabe:

```
failed to execute command: custom middleware through APIOptions is not supported in DAX client
exit status 1
```