# Etapa 4: executar uma aplicação de amostra
<a name="DAX.client.run-application"></a>

Para ajudar a testar a funcionalidade do Amazon DynamoDB Accelerator (DAX), você pode executar uma das aplicações de exemplo disponíveis em sua instância do Amazon EC2.

**Topics**
+ [Node.js e DAX](DAX.client.run-application-nodejs-3.md)
+ [DAX SDK for Go](DAX.client.run-application-go-2.md)
+ [Java e DAX](DAX.client.run-application-java.md)
+ [.NET e DAX](DAX.client.run-application-dotnet.md)
+ [Python e DAX](DAX.client.run-application-python.md)

# Node.js e DAX
<a name="DAX.client.run-application-nodejs-3"></a>

# Configuração do cliente padrão para Node.js
<a name="DAX-client-config-JS"></a>

Ao configurar o cliente SDK JavaScript do DAX, você pode personalizar vários parâmetros para otimizar a performance, o tratamento da conexão e a resiliência a erros. A tabela a seguir descreve as configurações padrão que controlam como o cliente interage com o cluster DAX, como valores de tempo limite, mecanismos de repetição, gerenciamento de credenciais e opções de monitoramento de integridade. Para ter mais informações, consulte [DynamoDBClient Operations](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/).


**Padrões do cliente SDK JS do DAX**  

| Parâmetro | Tipo | Descrição | 
| --- | --- | --- | 
|  `region` optional  |  `string`  |  A Região da AWS a ser usada para o cliente DAX (exemplo: “us-east-1”). É um parâmetro obrigatório caso não seja fornecido por meio da variável de ambiente.  | 
|  `endpoint` obrigatório  |  `string`  | O endpoint do cluster ao qual o SDK se conecta. Exemplos: Não criptografado: dax-cluster-name.region.amazonaws.com Criptografado: daxs://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com  | 
|  `requestTimeout` padrão 6.000 ms  |  `number`  | Isso define o tempo máximo que o cliente aguardará por uma resposta do DAX.  | 
|  `writeRetries` padrão 1  |  `number`  | O número de tentativas para solicitações de gravação que falharam.  | 
|  `readRetries` padrão 1  |  `number`  | O número de tentativas para solicitações de leitura que falharam.  | 
|  `maxRetries` padrão 1  |  `number`  | A quantidade máxima de tentativas após solicitações com falha. Se readRetries/writeRetries estiverem definidos, a configuração em readRetries e writeRetries terá prioridade sobre maxRetries.  | 
|  `connectTimeout` padrão 10.000 ms  |  `number`  | O tempo limite (em milissegundos) para estabelecer conexão com qualquer um dos nós do cluster.  | 
|  `maxConcurrentConnections` padrão 100  |  `number`  | Limita o número total de conexões simultâneas que uma instância cliente pode criar por nó em um cluster do DAX.  | 
|  `maxRetryDelay` padrão 7.000 ms  |  `number`  | Quando o servidor DAX indicar que a recuperação é necessária definindo o sinalizador `waitForRecoveryBeforeRetrying` como verdadeiro, o cliente fará uma pausa antes de tentar novamente. Durante esses períodos de recuperação, o parâmetro `maxRetryDelay` determina o tempo máximo de espera entre as tentativas. Essa configuração específica de recuperação só se aplica quando o servidor DAX está no modo de recuperação. Em todos os outros cenários, o comportamento de tentativa segue um dos dois padrões: um atraso exponencial com base na contagem de tentativas (controlado pelos parâmetros `writeRetries`, `readRetries` ou `maxRetries`) ou uma nova tentativa imediata, dependendo do tipo de exceção.  | 
|  `credentials` optional  |  `[AwsCredentialIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/)` \$1 `[AwsCredentialIdentityProvider](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/)`  |  As credenciais da AWS a serem usadas para autenticar solicitações. Isso pode ser fornecido como um AwsCredentialIdentity ou um AwsCredentialIdentityProvider. Se não for fornecido, o SDK da AWS usará automaticamente a cadeia de provedores de credenciais padrão. Exemplo: `\$1 accessKeyId: 'AKIA...', secretAccessKey: '...', sessionToken: '...' \$1` \$1 @default usa a cadeia de provedores de credenciais padrão da AWS.  | 
|  `healthCheckInterval` padrão 5.000 ms  |  `number`  | O intervalo (em milissegundos) entre as verificações de integridade do cluster. Um intervalo menor fará verificações com maior frequência.  | 
|  `healthCheckTimeout` padrão 1.000 ms  |  `number`  | O tempo limite (em milissegundos) para a conclusão da verificação de integridade.  | 
|  `skipHostnameVerification` padrão falso  |  `boolean`  |  Ignore a verificação do nome do host das conexões TLS. Isso não tem impacto em clusters não criptografados. O padrão é realizar a verificação do nome do host. Se definida como True, a verificação será ignorada. Você precisa entender a implicação de desativá-la, que é a impossibilidade de autenticar o cluster ao qual você está se conectando.   | 
|  `unhealthyConsecutiveErrorCount` padrão 5  |  `number`  | Define o número de erros consecutivos necessários para sinalizar que o nó não está íntegro no intervalo de verificação de integridade.  | 
|  `clusterUpdateInterval` padrão 4.000 ms  |  `number`  | Exibe o intervalo entre as sondagens dos membros do cluster para alterações de associação.  | 
|  `clusterUpdateThreshold` padrão 125  |  `number`  | Exibe o limite abaixo do qual o cluster não será sondado para alterações de associação.  | 
|  `credentailProvider` opcional \$1 padrão nulo  |  `[AwsCredentialIdentityProvider](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/)`  | Provedor definido pelo usuário para credenciais da AWS usadas para autenticar solicitações ao DAX.  | 


**Configuração de paginação para DaxDocument**  

| Nome | Tipo | Detalhes | 
| --- | --- | --- | 
|  `client`  |  DaxDocument  |  Instância do tipo DaxDocument.  | 
|  `pageSize`  |  número  |  Determina o número de itens por página.  | 
|  `startingToken` Opcional  |  quaisquer  |  A LastEvaluatedKey da resposta anterior pode ser usada para solicitações subsequentes.  | 

Quanto ao uso da paginação, consulte [TryDax.js](DAX.client.tutorial-TryDax.md).

# Migrar para o DAX Node.js SDK V3
<a name="DAX.client.run-application-nodejs-3-migrating"></a>

Este guia de migração ajudará você a fazer a transição de aplicações DAX Node.js existentes. O novo SDK requer o Node.js 18 ou posterior e introduz várias alterações importantes na forma como você estruturará o código do DynamoDB Accelerator. Este guia explicará as principais diferenças, incluindo alterações de sintaxe, novos métodos de importação e padrões de programação assíncrona atualizados.

## Uso do DAX Node.js V2
<a name="DAX.client.run-application-nodejs-3-migrating-V2-usage"></a>

```
const AmazonDaxClient = require('amazon-dax-client');
const AWS = require('aws-sdk');

var region = "us-west-2";

AWS.config.update({
  region: region,
});

var client = new AWS.DynamoDB.DocumentClient();

if (process.argv.length > 2) {
  var dax = new AmazonDaxClient({
    endpoints: [process.argv[2]],
    region: region,
  });
  client = new AWS.DynamoDB.DocumentClient({ service: dax });
}

// Make Get Call using Dax
var params = {
    TableName: 'TryDaxTable',
    pk: 1,
    sk: 1
}
client.get(params, function (err, data) {
    if (err) {
        console.error(
            "Unable to read item. Error JSON:",
            JSON.stringify(err, null, 2)
          );
    } else {
        console.log(data);
    }
});
```

## Uso do DAX Node.js V3
<a name="DAX.client.run-application-nodejs-3-migrating-V3-dax-usage"></a>

Para usar o DAX Node.js V3, a versão 18 ou posterior do Node é a versão preferencial. Para mudar para o Node 18, use o seguinte:

```
import { DaxDocument } from '@amazon-dax-sdk/lib-dax';
import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';

let client: DynamoDBDocument | DaxDocument = DynamoDBDocument.from(
  new DynamoDBClient({ region: 'us-west-2' })
);

if (process.argv.length > 2) {
  client = new DaxDocument({
    endpoints: [process.argv[2]],
    region: 'us-west-2',
  });
}

const params = {
  TableName: 'TryDaxTable',
  Key: { pk: 1, sk: 1 },
};

try {
  const results = await client.get(params);
  console.log(results);
} catch (err) {
  console.error(err);
}
```

O DAX SDK para Node.js v3.x é compatível com o [AWS SDK para Node.js v3.x](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/). O DAX SDK para Node.js v3.x aceita o uso de clientes [agregados](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/#high-level-concepts). Observe que o DAX não aceita a criação de clientes básicos. Para ter mais detalhes sobre os recursos não aceitos, consulte [Recursos que não estão em paridade com o AWS SDK para V3](#DAX.client.run-application-nodejs-3-not-in-parity).

Siga estas etapas para executar a aplicação de exemplo em Node.js na instância do Amazon EC2.

**Para executar o exemplo em Node.js para DAX**

1. Configure o Node.js na instância do Amazon EC2 da seguinte forma:

   1. Instale o gerenciador de versão de nó (`nvm`).

      ```
      curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
      ```

   1. Use o nvm para instalar o Node.js.

      ```
      nvm install 18
      ```

   1. Usar nvm para utilizar o Node 18

      ```
      nvm use 18
      ```

   1. Verifique se o Node.js está instalado e funcionando corretamente.

      ```
      node -e "console.log('Running Node.js ' + process.version)"
      ```

      Isso deve exibir a seguinte mensagem.

      `Running Node.js v18.x.x`

1. Instale o cliente Node.js do DaxDocument usando o gerenciador de pacotes de nó (`npm`).

   ```
   npm install @amazon-dax-sdk/lib-dax
   ```

## Código de exemplo do TryDax
<a name="DAX.client.run-application-nodejs-3-TryDax-sample-code"></a>

Se quiser avaliar os benefícios de performance do DynamoDB Accelerator (DAX), siga estas etapas para executar um teste de amostra que compara os tempos de operação de leitura entre o DynamoDB padrão e um cluster do DAX.

1. Depois de configurar seu espaço de trabalho e instalar o `lib-dax` como uma dependência, copie [TryDax.js](DAX.client.tutorial-TryDax.md) no projeto.

1. Execute o programa no cluster do DAX. Para determinar o endpoint do cluster do DAX, escolha uma das seguintes opções: 
   +  **Usando o console do DynamoDB**: escolha seu cluster do DAX. O endpoint do cluster é mostrado no console, como no exemplo a seguir.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Usando a AWS CLI**: insira o comando a seguir.

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

     O endpoint do cluster é mostrado na saída, como no exemplo a seguir.

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

1. Agora execute o programa especificando o endpoint do cluster como um parâmetro de linha de comandos.

   ```
   node TryDax.js dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   ```

   Você deve ver uma saída semelhante a:

   ```
   Attempting to create table; please wait...
   Successfully created table. Table status: ACTIVE
   Writing data to the table...
   Writing 20 items for partition key:  1
   Writing 20 items for partition key:  2
   Writing 20 items for partition key:  3
   ...
   Running GetItem Test
           Total time: 153555.10 µs - Avg time: 383.89 µs
           Total time: 44679.96 µs - Avg time: 111.70 µs
           Total time: 36885.86 µs - Avg time: 92.21 µs
           Total time: 32467.25 µs - Avg time: 81.17 µs
           Total time: 32202.60 µs - Avg time: 80.51 µs
   Running Query Test
           Total time: 14869.25 µs - Avg time: 2973.85 µs
           Total time: 3036.31 µs - Avg time: 607.26 µs
           Total time: 2468.92 µs - Avg time: 493.78 µs
           Total time: 2062.53 µs - Avg time: 412.51 µs
           Total time: 2178.22 µs - Avg time: 435.64 µs
   Running Scan Test
           Total time: 2395.88 µs - Avg time: 479.18 µs
           Total time: 2207.16 µs - Avg time: 441.43 µs
           Total time: 2443.14 µs - Avg time: 488.63 µs
           Total time: 2038.24 µs - Avg time: 407.65 µs
           Total time: 1972.17 µs - Avg time: 394.43 µs
   Running Pagination Test
   Scan Pagination
   [
     { pk: 1, sk: 1, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 2, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 3, someData: 'XXXXXXXXXX' }
   ]
   [
     { pk: 1, sk: 4, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 5, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 6, someData: 'XXXXXXXXXX' }
   ]
   ...
   Query Pagination
   [
     { pk: 1, sk: 1, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 2, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 3, someData: 'XXXXXXXXXX' }
   ]
   [
     { pk: 1, sk: 4, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 5, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 6, someData: 'XXXXXXXXXX' }
   ]
   ...
   Attempting to delete table; please wait...
   Successfully deleted table.
   ```

   Anote as informações de tempo. O número de microssegundos necessários para os testes `GetItem`, `Query` e `Scan`.

1. Nesse caso, você executou os programas no cluster do DAX. Agora você executará o programa novamente, desta vez no DynamoDB.

1. Execute o programa novamente, mas, desta vez, sem o URL do endpoint do cluster como um parâmetro de linha de comandos.

   ```
   node TryDax.js
   ```

   Observe o restante da saída e anote as informações de tempo. Os tempos decorridos para `GetItem`, `Query` e `Scan` devem ser muito mais baixos com o DAX em comparação ao DynamoDB.

## Recursos que não estão em paridade com o AWS SDK para V3
<a name="DAX.client.run-application-nodejs-3-not-in-parity"></a>
+ [Clientes básicos](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/#high-level-concepts): o Dax Node.js V3 não aceita clientes básicos. 

  ```
  const dynamoDBClient = new DynamoDBClient({ region: 'us-west-2' });
  const regularParams = {
      TableName: 'TryDaxTable',
      Key: {
          pk: 1,
          sk: 1
      }
  };
  // The DynamoDB client supports the send operation.
  const dynamoResult = await dynamoDBClient.send(new GetCommand(regularParams));
  
  // However, the DaxDocument client does not support the send operation.
  const daxClient = new DaxDocument({
      endpoints: ['your-dax-endpoint'],
      region: 'us-west-2',
  });
  
  const params = {
      TableName: 'TryDaxTable',
      Key: {
          pk: 1,
          sk: 1
      }
  };
  
  // This will throw an error - send operation is not supported for DAX. Please refer to documentation.
  const result = await daxClient.send(new GetCommand(params));
  console.log(result);
  ```
+ [Middleware Stack](https://aws.amazon.com/blogs/developer/middleware-stack-modular-aws-sdk-js/): o Dax Node.js V3 não comporta o uso de funções de Middleware.

  ```
  const dynamoDBClient = new DynamoDBClient({ region: 'us-west-2' });
  // The DynamoDB client supports the middlewareStack.
  dynamoDBClient.middlewareStack.add(
    (next, context) =>> async (args) => {
      console.log("Before operation:", args);
      const result = await next(args);
      console.log("After operation:", result);
      return result;
    },
    {
      step: "initialize", // or "build", "finalizeRequest", "deserialize"
      name: "loggingMiddleware",
    }
  );
  
  // However, the DaxDocument client does not support the middlewareStack.
  const daxClient = new DaxDocument({
      endpoints: ['your-dax-endpoint'],
      region: 'us-west-2',
  });
  
  // This will throw an error - custom middleware and middlewareStacks are not supported for DAX. Please refer to documentation.
  daxClient.middlewareStack.add(
    (next, context) => async (args) => {
      console.log("Before operation:", args);
      const result = await next(args);
      console.log("After operation:", result);
      return result;
    },
    {
      step: "initialize", // or "build", "finalizeRequest", "deserialize"
      name: "loggingMiddleware",
    }
  );
  ```

# TryDax.js
<a name="DAX.client.tutorial-TryDax"></a>

```
import { DynamoDB, waitUntilTableExists, waitUntilTableNotExists } from "@aws-sdk/client-dynamodb";
import { DaxDocument, daxPaginateScan, daxPaginateQuery } from "@amazon-dax-sdk/lib-dax";
import { DynamoDBDocument, paginateQuery, paginateScan } from "@aws-sdk/lib-dynamodb";

const region = "us-east-1";
const tableName = "TryDaxTable";

// Determine the client (DynamoDB or DAX)
let client = DynamoDBDocument.from(new DynamoDB({ region }));
if (process.argv.length > 2) {
  client = new DaxDocument({ region, endpoint: process.argv[2] });
}

// Function to create table
async function createTable() {
  const dynamodb = new DynamoDB({ region });
  const params = {
    TableName: tableName,
    KeySchema: [
      { AttributeName: "pk", KeyType: "HASH" },
      { AttributeName: "sk", KeyType: "RANGE" },
    ],
    AttributeDefinitions: [
      { AttributeName: "pk", AttributeType: "N" },
      { AttributeName: "sk", AttributeType: "N" },
    ],
    ProvisionedThroughput: { ReadCapacityUnits: 25, WriteCapacityUnits: 25 },
  };

  try {
    console.log("Attempting to create table; please wait...");
    await dynamodb.createTable(params);
    await waitUntilTableExists({ client: dynamodb, maxWaitTime: 30 }, { TableName: tableName });
    console.log("Successfully created table. Table status: ACTIVE");
  } catch (err) {
    console.error("Error in table creation:", err);
  }
}

// Function to insert data
async function writeData() {
  console.log("Writing data to the table...");
  const someData = "X".repeat(10);
  for (let ipk = 1; ipk <= 20; ipk++) {
    console.log("Writing 20 items for partition key: ", ipk)
    for (let isk = 1; isk <= 20; isk++) {
      try {
        await client.put({ TableName: tableName, Item: { pk: ipk, sk: isk, someData } });
      } catch (err) {
        console.error("Error inserting data:", err);
      }
    }
  }
}

// Function to test GetItem
async function getItemTest() {
  console.log("Running GetItem Test");
  for (let i = 0; i < 5; i++) {
    const startTime = performance.now();
    const promises = [];
    for (let ipk = 1; ipk <= 20; ipk++) {
      for (let isk = 1; isk <= 20; isk++) {
        promises.push(client.get({ TableName: tableName, Key: { pk: ipk, sk: isk } }));
      }
    }
    await Promise.all(promises);
    const endTime = performance.now();
    const iterTime = (endTime - startTime) * 1000;
    const totalTime = iterTime.toFixed(2).padStart(3, ' ');
    const avgTime = (iterTime / 400).toFixed(2).padStart(3, ' ');
    console.log(`\tTotal time: ${totalTime} \u00B5s - Avg time: ${avgTime} \u00B5s`);
  }
}

// Function to test Query
async function queryTest() {
  console.log("Running Query Test");
  for (let i = 0; i < 5; i++) {
    const startTime = performance.now();
    const promises = [];
    for (let pk = 1; pk <= 5; pk++) {
      const params = {
        TableName: tableName,
        KeyConditionExpression: "pk = :pkval and sk between :skval1 and :skval2",
        ExpressionAttributeValues: { ":pkval": pk, ":skval1": 1, ":skval2": 2 },
      };
      promises.push(client.query(params));
    }
    await Promise.all(promises);
    const endTime = performance.now();
    const iterTime = (endTime - startTime) * 1000;
    const totalTime = iterTime.toFixed(2).padStart(3, ' ');
    const avgTime = (iterTime / 5).toFixed(2).padStart(3, ' ');
    console.log(`\tTotal time: ${totalTime} \u00B5s - Avg time: ${avgTime} \u00B5s`);
  }
}

// Function to test Scan
async function scanTest() {
  console.log("Running Scan Test");
  for (let i = 0; i < 5; i++) {
    const startTime = performance.now();
    const promises = [];
    for (let pk = 1; pk <= 5; pk++) {
      const params = {
        TableName: tableName,
        FilterExpression: "pk = :pkval and sk between :skval1 and :skval2",
        ExpressionAttributeValues: { ":pkval": pk, ":skval1": 1, ":skval2": 2 },
      };
      promises.push(client.scan(params));
    }
    await Promise.all(promises);
    const endTime = performance.now();
    const iterTime = (endTime - startTime) * 1000;
    const totalTime = iterTime.toFixed(2).padStart(3, ' ');
    const avgTime = (iterTime / 5).toFixed(2).padStart(3, ' ');
    console.log(`\tTotal time: ${totalTime} \u00B5s - Avg time: ${avgTime} \u00B5s`);
  }
}

// Function to test Pagination
async function paginationTest() {
  console.log("Running Pagination Test");
  console.log("Scan Pagination");
  const scanParams = { TableName: tableName };
  const paginator = process.argv.length > 2 ? daxPaginateScan : paginateScan;
  for await (const page of paginator({ client, pageSize: 3 }, scanParams)) {
    console.log(page.Items);
  }

  console.log("Query Pagination");
  const queryParams = {
    TableName: tableName,
    KeyConditionExpression: "pk = :pkval and sk between :skval1 and :skval2",
    ExpressionAttributeValues: { ":pkval": 1, ":skval1": 1, ":skval2": 10 },
  };
  const queryPaginator = process.argv.length > 2 ? daxPaginateQuery : paginateQuery;
  for await (const page of queryPaginator({ client, pageSize: 3 }, queryParams)) {
    console.log(page.Items);
  }
}

// Function to delete the table
async function deleteTable() {
  const dynamodb = new DynamoDB({ region });
  console.log("Attempting to delete table; please wait...")
  try {
    await dynamodb.deleteTable({ TableName: tableName });
    await waitUntilTableNotExists({ client: dynamodb, maxWaitTime: 30 }, { TableName: tableName });
    console.log("Successfully deleted table.");
  } catch (err) {
    console.error("Error deleting table:", err);
  }
}

// Execute functions sequentially
(async function () {
  await createTable();
  await writeData();
  await getItemTest();
  await queryTest();
  await scanTest();
  await paginationTest();
  await deleteTable();
})();
```

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

Siga este procedimento para executar o exemplo do SDK for Go para Amazon DynamoDB Accelerator (DAX) em sua instância do Amazon EC2.

**Para executar o exemplo do SDK for Go para DAX**

1. Configure o SDK for Go em sua instância do Amazon EC2:

   1. Instale a linguagem de programação Go (`Golang`).

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

   1. Verifique se o Golang está instalado e funcionando corretamente.

      ```
      go version
      ```

      Uma mensagem semelhante a esta deve ser mostrada.

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

1. Instale o aplicativo de exemplo do Golang.

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

1. Execute os seguintes programas do Golang. O primeiro programa cria uma tabela do DynamoDB chamada `TryDaxGoTable`. O segundo programa grava dados na tabela.

   ```
   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. Execute os seguintes programas do Golang.

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

   Anote as informações de tempo: o número de milissegundos necessários para os testes `GetItem`, `Query` e `Scan`.

1. Na etapa anterior, você executou os programas no endpoint do DynamoDB. Agora, execute os programas novamente, mas, desta vez, as operações `GetItem`, `Query` e `Scan` são processadas pelo cluster do DAX.

   Para determinar o endpoint do cluster do DAX, escolha uma das seguintes opções:
   + **Usando o console do DynamoDB**: escolha seu cluster do DAX. O endpoint do cluster é mostrado no console, como no exemplo a seguir.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Usando a AWS CLI**: insira o comando a seguir.

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

     O endpoint do cluster é mostrado na saída, como no exemplo a seguir.

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

   Agora, execute os programas novamente, mas, desta vez, especifique o endpoint do cluster como um parâmetro de linha de comando.

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

   Observe o restante da saída e anote as informações de tempo. Os tempos decorridos para `GetItem`, `Query` e `Scan` devem ser significativamente mais baixos com o DAX do que com o DynamoDB.

1. Execute o seguinte programa Golang para excluir a `TryDaxGoTable`.

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

## Recursos que não estão em paridade com o AWS SDK para Go V2
<a name="DAX.client.run-application-go-features-not-in-parity"></a>

Pilha de middleware: o DAX Go V2 não aceita o uso de pilhas de middleware por meio de APIoptions. Para ter mais informações, consulte [Customizing the AWS SDK para Go v2 Client Requests with Middleware](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).

Exemplo:

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

Resultado:

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

# Configuração de cliente padrão para Go
<a name="DAX-client-config-Go"></a>

Este guia explicará as opções de configuração que permitem ajustar a performance, o gerenciamento de conexões e o comportamento de registro em log do cliente DAX. Ao entender as configurações padrão e como personalizá-las, você pode otimizar a interação da aplicação Go com o DAX.

**Topics**
+ [Padrões do cliente DAX Go SDK](#DAX-client-config-Go-sdk-client-defaults)
+ [Criação de cliente](#DAX-client-config-Go-client-creation)

## Padrões do cliente DAX Go SDK
<a name="DAX-client-config-Go-sdk-client-defaults"></a>


| Parâmetro | Tipo | Descrição | 
| --- | --- | --- | 
|  `Region` obrigatório  |  `string`  |  A Região da AWS a ser usada para o cliente DAX (exemplo: “us-east-1”). É um parâmetro obrigatório caso não seja fornecido por meio do ambiente.  | 
|  `HostPorts` obrigatório  |  `[] string`  |  Lista de endpoints do cluster DAX aos quais o SDK se conecta.  Por exemplo: Não criptografado: dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com Criptografado: daxs://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com  | 
|  `MaxPendingConnectionsPerHost` padrão 10  |  `number`  | O número de tentativas de conexão simultâneas. (As conexões podem estar no processo de ser estabelecidas simultaneamente.)  | 
|  `ClusterUpdateThreshold` padrão 125 \$1 time.Millisecond  |  `time.Duration`  | O tempo mínimo que deve decorrer entre as atualizações do cluster.  | 
|  `ClusterUpdateInterval` padrão 4 \$1 time.Second  |  `time.Duration`  | O intervalo no qual o cliente atualizará automaticamente as informações do cluster DAX.  | 
|  `IdleConnectionsReapDelay` padrão 30 \$1 time.Second  |  `time.Duration`  | O intervalo no qual o cliente fechará conexões ociosas no cliente DAX.  | 
|  `ClientHealthCheckInterval` padrão 5 \$1 time.Second  |  `time.Duration`  | O intervalo no qual o cliente realizará verificações de integridade nos endpoints do cluster DAX.  | 
|  `Credentials` padrão  |  `aws.CredentialsProvider`  | As credenciais da AWS usadas pelo cliente DAX para autenticar solicitações no serviço DAX. Consulte [Credentials and Credential Providers](https://docs.aws.amazon.com/sdk-for-go/v2/developer-guide/migrate-gosdk.html#credentials--credential-providers).  | 
|  `DialContext` padrão  |  `func`  | Uma função personalizada usada pelo cliente DAX para estabelecer conexões com o cluster DAX.  | 
|  `SkipHostnameVerification` padrão falso  |  bool  |  Ignore a verificação do nome do host das conexões TLS. Essa configuração afeta somente clusters criptografados. Quando definida como True, ela desativa a verificação do nome do host. Quando você desabilita a verificação, não consegue autenticar a identidade do cluster ao qual está se conectando, o que gera riscos de segurança. Por padrão, a verificação do nome do host fica habilitada.  | 
|  `RouteManagerEnabled` padrão falso  |  `bool`  | Esse sinalizador é usado para remover rotas que enfrentam erros de rede.  | 
|  `RequestTimeout` padrão 60 \$1 time.Second  |  `time.Duration`  | Isso define o tempo máximo que o cliente aguardará por uma resposta do DAX. Prioridade: tempo limite do contexto (se definido) > `RequestTimmeout` (se definido) > `RequestTimeout` padrão de 60 s.  | 
|  `WriteRetries` padrão 2  |  `number`  |  O número de tentativas para solicitações de gravação que falharam.  | 
|  `ReadRetries` padrão 2  |  `number`  | O número de tentativas para solicitações de leitura que falharam.  | 
|  `RetryDelay` padrão 0  |  `time.Duration`  | O atraso para erros não limitados (em segundos) nas tentativas de repetição quando uma solicitação falha.  | 
|  `Logger` optional  |  `logging.Logger`  | Logger é uma interface para registrar em log entradas em determinadas classificações.  | 
|  `LogLevel` padrão utils.LogOff  |  `number`  | Esse nível de log é definido somente para DAX. Ele pode ser importado usando [github.com/aws/aws-dax-go-v2/tree/main/dax/utils](https://github.com/aws/aws-dax-go-v2/tree/main/dax/utils).  <pre>const (    <br /> LogOff LogLevelType = 0   <br /> LogDebug LogLevelType = 1   <br /> LogDebugWithRequestRetries<br /> LogLevelType = 2<br />)</pre>  | 

**nota**  
Em `time.Duration`, a unidade padrão é nanossegundo. Se não especificarmos nenhuma unidade para nenhum parâmetro, ele considerará isso como nanossegundos: `daxCfg.ClusterUpdateInterval = 10` significa 10 nanossegundos. (`daxCfg.ClusterUpdateInterval = 10 * time.Millisecond` significa 10 milissegundos).

## Criação de cliente
<a name="DAX-client-config-Go-client-creation"></a>

**Para criar um cliente DAX:**
+ Crie a configuração do DAX e, depois, crie o cliente DAX usando a configuração do DAX. Assim, você poderá substituir uma configuração do DAX, se necessário.

  ```
  import (
  "github.com/aws/aws-dax-go-v2/dax/utils"
  "github.com/aws/aws-dax-go-v2/dax"
  )
  
  // Non - Encrypted : 'dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com'.
  // Encrypted : daxs://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com'.
  
  config := dax.DefaultConfig()
  config.HostPorts = []string{endpoint}
  config.Region = region
  config.LogLevel = utils.LogDebug
  daxClient, err := dax.New(config)
  ```

# Migrar para o DAX Go SDK V2
<a name="DAX.client.run-application-go-migrating"></a>

Este guia de migração ajudará você a fazer a transição de aplicações DAX Go existentes.

## Uso do V1 DAX Go SDK
<a name="DAX.client.run-application-go-V1-usage"></a>

```
package main

import (
    "fmt"
    "os"

    "github.com/aws/aws-dax-go/dax"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/dynamodb"
)

func main() {
    region := "us-west-2"
    endpoint := "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
    
    // Create session
    sess, err := session.NewSession(&aws.Config{
        Region: aws.String(region),
    })
    if err != nil {
        fmt.Printf("Failed to create session: %v\n", err)
        os.Exit(1)
    }
    
    // Configure DAX client
    cfg := dax.DefaultConfig()
    cfg.HostPorts = []string{endpoint} 
    cfg.Region = region

    // Create DAX client
    daxClient, err := dax.New(cfg)
    if err != nil {
        fmt.Printf("Failed to create DAX client: %v\n", err)
        os.Exit(1)
    }
    defer daxClient.Close() // Don't forget to close the client

    // Create GetItem input
    input := &dynamodb.GetItemInput{
        TableName: aws.String("TryDaxTable"),
        Key: map[string]*dynamodb.AttributeValue{
            "pk": {
                N: aws.String("1"),
            },
            "sk": {
                N: aws.String("1"),
            },
        },
    }

    // Make the GetItem call
    result, err := daxClient.GetItem(input)
    if err != nil {
        fmt.Printf("Failed to get item: %v\n", err)
        os.Exit(1)
    }

    // Print the result
    fmt.Printf("GetItem succeeded: %+v\n", result)
}
```

## Uso do V2 DAX Go SDK
<a name="DAX.client.run-application-go-V2-usage"></a>

```
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/aws/aws-dax-go-v2/dax"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
    "github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
    "github.com/aws/aws-sdk-go-v2/aws"
)

func main() {
    ctx := context.Background()
    region := "us-west-2"
    endpoint := "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
   
    // Create DAX config
    config := dax.DefaultConfig()
    // Specify Endpoint and Region
    config.HostPorts = []string{endpoint}
    config.Region = region
    // Enabling logging
    config.LogLevel = utils.LogDebug
    // Create DAX client
    daxClient, err := dax.New(config) 
    if err != nil {
        fmt.Printf("Failed to create DAX client: %v\n", err)
        os.Exit(1)
    }
    defer daxClient.Close() // Don't forget to close the client

    // 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)
    }
                
    // Create GetItem input
    input := &dynamodb.GetItemInput{
        TableName: aws.String("TryDaxTable"),
        Key: map[string]types.AttributeValue{
             "pk": pk,
             "sk": sk,
        },
    }

    // Make the GetItem call
    result, err := daxClient.GetItem(ctx, input)
    if err != nil {
        fmt.Printf("Failed to get item: %v\n", err)
        os.Exit(1)
    }

    // Print the result
    fmt.Printf("GetItem succeeded: %+v\n", result)
}
```

Para ter mais detalhes sobre o uso de API, consulte [Amostras da AWS](https://github.com/aws-samples/sample-aws-dax-go-v2).

# Java e DAX
<a name="DAX.client.run-application-java"></a>

O DAX SDK para Java 2.x é compatível com o [AWSSDK para Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/). Ele foi criado com base no Java 8\$1 e inclui suporte a E/S sem bloqueio. Para ter informações sobre como usar o DAX com o AWS SDK para Java 1.x, consulte [Uso do DAX com o AWS SDK for Java 1.x](DAX.client.java-sdk-v1.md).

## Como usar o cliente como uma dependência do Maven
<a name="DAX.client.run-application-java.maven"></a>

Siga estas etapas para usar o cliente do SDK do DAX para Java em seu aplicativo como uma dependência.

1. Faça download do Apache Maven e instale-o. Para obter mais informações, consulte [Download do Apache Maven](https://maven.apache.org/download.cgi) e [Instalação do Apache Maven](https://maven.apache.org/install.html).

1. Adicione a dependência do cliente Maven ao arquivo Project Object Model (POM) da aplicação. Neste exemplo, substitua *x.x.x* pelo número da versão real do cliente.

   ```
   <!--Dependency:-->
   <dependencies>
       <dependency>
           <groupId>software.amazon.dax</groupId>
           <artifactId>amazon-dax-client</artifactId>
           <version>x.x.x</version>
       </dependency>
   </dependencies>
   ```

## Código de exemplo do TryDax
<a name="DAX.client.run-application-java.sample"></a>

Depois de configurar seu espaço de trabalho e adicionar o DAX SDK como uma dependência, copie[TryDax.java](DAX.client.TryDax.java.md) para seu projeto.

Execute o código usando este comando.

```
java -cp classpath TryDax
```

Você deve ver saída semelhante ao seguinte:

```
Creating a DynamoDB client

Attempting to create table; please wait...
Successfully created table.  Table status: ACTIVE
Writing data to the table...
Writing 10 items for partition key: 1
Writing 10 items for partition key: 2
Writing 10 items for partition key: 3
...

Running GetItem and Query tests...
First iteration of each test will result in cache misses
Next iterations are cache hits

GetItem test - partition key 1-100 and sort keys 1-10
  Total time: 4390.240 ms - Avg time: 4.390 ms
  Total time: 3097.089 ms - Avg time: 3.097 ms
  Total time: 3273.463 ms - Avg time: 3.273 ms
  Total time: 3353.739 ms - Avg time: 3.354 ms
  Total time: 3533.314 ms - Avg time: 3.533 ms
Query test - partition key 1-100 and sort keys between 2 and 9
  Total time: 475.868 ms - Avg time: 4.759 ms
  Total time: 423.333 ms - Avg time: 4.233 ms
  Total time: 460.271 ms - Avg time: 4.603 ms
  Total time: 397.859 ms - Avg time: 3.979 ms
  Total time: 466.644 ms - Avg time: 4.666 ms

Attempting to delete table; please wait...
Successfully deleted table.
```

Anote as informações de tempo — o número de milissegundos necessários para os testes `GetItem` e `Query`. Neste caso, você executou o programa no endpoint do DynamoDB. Agora você executará o programa novamente, desta vez em seu cluster do DAX.

Para determinar o endpoint do cluster do DAX, escolha uma das seguintes opções:
+ Usando o console do DynamoDB, selecione seu cluster do DAX. O endpoint do cluster é mostrado no console, como no exemplo a seguir.

  ```
  dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
  ```
+ Usando a AWS CLI, insira o comando seguir.

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

  A porta, o endereço e o URL do endpoint do cluster aparecem na saída, como no exemplo a seguir.

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

Agora execute o programa novamente, mas, desta vez, especifique o URL do endpoint do cluster como um parâmetro de linha de comando.

```
java -cp classpath TryDax dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```

Observe o restante da saída e anote as informações de tempo. Os tempos decorridos para `GetItem` e `Query` devem ser significativamente mais baixos com o DAX do que com o DynamoDB.

## Métricas do SDK
<a name="DAX.client.run-application-java.metrics"></a>

Com o DAX SDK para Java 2.x, você pode coletar métricas sobre os clientes de serviço em sua aplicação e analisar a saída no Amazon CloudWatch. Consulte [Habilitar métricas do SDK](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/metrics.html) para obter mais informações.

**nota**  
O DAX SDK para Java coleta somente métricas `ApiCallSuccessful` e `ApiCallDuration`.

# TryDax.java
<a name="DAX.client.TryDax.java"></a>

```
import java.util.Map;

import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.BillingMode;
import software.amazon.awssdk.services.dynamodb.model.CreateTableRequest;
import software.amazon.awssdk.services.dynamodb.model.DeleteTableRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeTableRequest;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import software.amazon.awssdk.services.dynamodb.model.KeySchemaElement;
import software.amazon.awssdk.services.dynamodb.model.KeyType;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.QueryRequest;
import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType;
import software.amazon.dax.ClusterDaxAsyncClient;
import software.amazon.dax.Configuration;

public class TryDax {
    public static void main(String[] args) throws Exception {
        DynamoDbAsyncClient ddbClient = DynamoDbAsyncClient.builder()
                .build();

        DynamoDbAsyncClient daxClient = null;
        if (args.length >= 1) {
            daxClient = ClusterDaxAsyncClient.builder()
                    .overrideConfiguration(Configuration.builder()
                            .url(args[0]) // e.g. dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
                            .build())
                    .build();
        }

        String tableName = "TryDaxTable";

        System.out.println("Creating table...");
        createTable(tableName, ddbClient);

        System.out.println("Populating table...");
        writeData(tableName, ddbClient, 100, 10);

        DynamoDbAsyncClient testClient = null;
        if (daxClient != null) {
            testClient = daxClient;
        } else {
            testClient = ddbClient;
        }

        System.out.println("Running GetItem and Query tests...");
        System.out.println("First iteration of each test will result in cache misses");
        System.out.println("Next iterations are cache hits\n");

        // GetItem
        getItemTest(tableName, testClient, 100, 10, 5);

        // Query
        queryTest(tableName, testClient, 100, 2, 9, 5);

        System.out.println("Deleting table...");
        deleteTable(tableName, ddbClient);
    }

    private static void createTable(String tableName, DynamoDbAsyncClient client) {
        try {
            System.out.println("Attempting to create table; please wait...");

            client.createTable(CreateTableRequest.builder()
                    .tableName(tableName)
                    .keySchema(KeySchemaElement.builder()
                            .keyType(KeyType.HASH)
                            .attributeName("pk")
                            .build(), KeySchemaElement.builder()
                            .keyType(KeyType.RANGE)
                            .attributeName("sk")
                            .build())
                    .attributeDefinitions(AttributeDefinition.builder()
                            .attributeName("pk")
                            .attributeType(ScalarAttributeType.N)
                            .build(), AttributeDefinition.builder()
                            .attributeName("sk")
                            .attributeType(ScalarAttributeType.N)
                            .build())
                    .billingMode(BillingMode.PAY_PER_REQUEST)
                    .build()).get();
            client.waiter().waitUntilTableExists(DescribeTableRequest.builder()
                    .tableName(tableName)
                    .build()).get();
            System.out.println("Successfully created table.");

        } catch (Exception e) {
            System.err.println("Unable to create table: ");
            e.printStackTrace();
        }
    }

    private static void deleteTable(String tableName, DynamoDbAsyncClient client) {
        try {
            System.out.println("\nAttempting to delete table; please wait...");
            client.deleteTable(DeleteTableRequest.builder()
                    .tableName(tableName)
                    .build()).get();
            client.waiter().waitUntilTableNotExists(DescribeTableRequest.builder()
                    .tableName(tableName)
                    .build()).get();
            System.out.println("Successfully deleted table.");

        } catch (Exception e) {
            System.err.println("Unable to delete table: ");
            e.printStackTrace();
        }
    }

    private static void writeData(String tableName, DynamoDbAsyncClient client, int pkmax, int skmax) {
        System.out.println("Writing data to the table...");

        int stringSize = 1000;
        StringBuilder sb = new StringBuilder(stringSize);
        for (int i = 0; i < stringSize; i++) {
            sb.append('X');
        }
        String someData = sb.toString();

        try {
            for (int ipk = 1; ipk <= pkmax; ipk++) {
                System.out.println(("Writing " + skmax + " items for partition key: " + ipk));
                for (int isk = 1; isk <= skmax; isk++) {
                    client.putItem(PutItemRequest.builder()
                            .tableName(tableName)
                            .item(Map.of("pk", attr(ipk), "sk", attr(isk), "someData", attr(someData)))
                            .build()).get();
                }
            }
        } catch (Exception e) {
            System.err.println("Unable to write item:");
            e.printStackTrace();
        }
    }

    private static AttributeValue attr(int n) {
        return AttributeValue.builder().n(String.valueOf(n)).build();
    }

    private static AttributeValue attr(String s) {
        return AttributeValue.builder().s(s).build();
    }

    private static void getItemTest(String tableName, DynamoDbAsyncClient client, int pk, int sk, int iterations) {
        long startTime, endTime;
        System.out.println("GetItem test - partition key 1-" + pk + " and sort keys 1-" + sk);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            try {
                for (int ipk = 1; ipk <= pk; ipk++) {
                    for (int isk = 1; isk <= sk; isk++) {
                        client.getItem(GetItemRequest.builder()
                                .tableName(tableName)
                                .key(Map.of("pk", attr(ipk), "sk", attr(isk)))
                                .build()).get();
                    }
                }
            } catch (Exception e) {
                System.err.println("Unable to get item:");
                e.printStackTrace();
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, pk * sk);
        }
    }

    private static void queryTest(String tableName, DynamoDbAsyncClient client, int pk, int sk1, int sk2, int iterations) {
        long startTime, endTime;
        System.out.println("Query test - partition key 1-" + pk + " and sort keys between " + sk1 + " and " + sk2);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            for (int ipk = 1; ipk <= pk; ipk++) {
                try {
                    // Pagination API for Query.
                    client.queryPaginator(QueryRequest.builder()
                            .tableName(tableName)
                            .keyConditionExpression("pk = :pkval and sk between :skval1 and :skval2")
                            .expressionAttributeValues(Map.of(":pkval", attr(ipk), ":skval1", attr(sk1), ":skval2", attr(sk2)))
                            .build()).items().subscribe((item) -> {
                    }).get();
                } catch (Exception e) {
                    System.err.println("Unable to query table:");
                    e.printStackTrace();
                }
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, pk);
        }
    }

    private static void printTime(long startTime, long endTime, int iterations) {
        System.out.format("\tTotal time: %.3f ms - ", (endTime - startTime) / (1000000.0));
        System.out.format("Avg time: %.3f ms\n", (endTime - startTime) / (iterations * 1000000.0));
    }
}
```

# .NET e DAX
<a name="DAX.client.run-application-dotnet"></a>

Siga estas etapas para executar o exemplo .NET na sua instância do Amazon EC2.

**nota**  
Este tutorial usa o SDK do .NET 9. Ele mostra como você pode executar um programa na sua Amazon VPC padrão para acessar seu cluster do Amazon DynamoDB Accelerator (DAX). Ele funciona com o [AWS SDK v4 para .NET](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html). Para acessar detalhes sobre as mudanças na V4 e informações sobre a migração, consulte [Migrar para a versão 4 do AWS SDK para .NET](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html). Se você preferir, pode usar o AWS Toolkit for Visual Studio para escrever um aplicativo .NET e implantá-lo em sua VPC.  
Para obter mais informações, consulte [Criação e implantação de aplicações do Elastic Beanstalk no .NET usando o AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_NET.html) no *Guia do desenvolvedor do AWS Elastic Beanstalk*.

**Como executar o exemplo do .NET para o DAX**

1. Acesse a [página Downloads da Microsoft](https://www.microsoft.com/net/download?initial-os=linux) e baixe o SDK do .NET 9 para Linux mais recente. O arquivo obtido por download é o `dotnet-sdk-N.N.N-linux-x64.tar.gz`.

1. Extraia os arquivos do SDK.

   ```
   mkdir dotnet
   tar zxvf dotnet-sdk-N.N.N-linux-x64.tar.gz -C dotnet
   ```

   Substitua `N.N.N` pelo número de versão real do SDK do .NET (por exemplo: `9.0.305`).

1. Verifique a instalação.

   ```
   alias dotnet=$HOME/dotnet/dotnet
   dotnet --version
   ```

   Isso deve imprimir o número da versão do SDK .NET.
**nota**  
Em vez de obter o número da versão, é possível que você receba o seguinte erro:  
erro: libunwind.so.8: não é possível abrir o arquivo do objeto compartilhado: o arquivo ou diretório não existe  
Para resolver o erro, instale o pacote `libunwind`.  

   ```
   sudo yum install -y libunwind
   ```
Depois disso, você deve conseguir executar o comando `dotnet --version` sem nenhum erro.

1. Crie um novo projeto .NET.

   ```
   dotnet new console -o myApp 
   ```

   Ele levará alguns minutos executando uma configuração isolada. Ao concluir, execute o projeto de exemplo.

   ```
   dotnet run --project myApp
   ```

   Você deverá receber a seguinte mensagem: `Hello World!`

1. O arquivo `myApp/myApp.csproj` contém os metadados do projeto. Para usar o cliente do DAX em sua aplicação, modifique o arquivo para que seja semelhante ao seguinte.

   ```
   <Project Sdk="Microsoft.NET.Sdk">
       <PropertyGroup>
           <OutputType>Exe</OutputType>
           <TargetFramework>net9.0</TargetFramework>
       </PropertyGroup>
       <ItemGroup>
           <PackageReference Include="AWSSDK.DAX.Client" Version="*" />
       </ItemGroup>
   </Project>
   ```

1. Baixe o código-fonte do programa de exemplo (arquivo `.zip`).

   ```
   wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
   ```

   Quando o download for concluído, extraia os arquivos de origem.

   ```
   unzip TryDax.zip
   ```

1. Agora, execute os programas de exemplo de *dotNet*, um por vez. Para cada programa, você copiará seu conteúdo em `myApp/Program.cs` e, seguida, executará o projeto `MyApp`.

   Execute os seguintes programas .NET. O primeiro programa cria uma tabela do DynamoDB chamada `TryDaxTable`. O segundo programa grava dados na tabela.

   ```
   cp TryDax/dotNet/01-CreateTable.cs myApp/Program.cs
   dotnet run --project myApp
   
   cp TryDax/dotNet/02-Write-Data.cs myApp/Program.cs
   dotnet run --project myApp
   ```

1. Depois, execute alguns programas para executar as operações `GetItem`, `Query` e `Scan` no cluster do DAX. Para determinar o endpoint do cluster do DAX, escolha uma das seguintes opções:
   +  **Usando o console do DynamoDB**: escolha seu cluster do DAX. O endpoint do cluster é mostrado no console, como no exemplo a seguir.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Usando a AWS CLI**: insira o comando a seguir.

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

     O endpoint do cluster é mostrado na saída, como no exemplo a seguir.

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

   Agora execute os seguintes programas, especificando o endpoint do cluster como um parâmetro de linha de comando. (Substitua o endpoint de exemplo pelo endpoint do seu cluster do DAX real.)

   ```
   cp TryDax/dotNet/03-GetItem-Test.cs myApp/Program.cs
   dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   
   cp TryDax/dotNet/04-Query-Test.cs myApp/Program.cs
   dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
                           
   cp TryDax/dotNet/05-Scan-Test.cs myApp/Program.cs
   dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   ```

   Anote as informações de tempo: o número de milissegundos necessários para os testes `GetItem`, `Query` e `Scan`.

1. Execute o seguinte programa .NET para excluir a `TryDaxTable`.

   ```
   cp TryDax/dotNet/06-DeleteTable.cs myApp/Program.cs
   dotnet run --project myApp
   ```

Para obter mais informações sobre esses programas, consulte as seguintes seções:
+ [01-CreateTable.cs](DAX.client.run-application-dotnet.01-CreateTable.md)
+ [02-Write-Data.cs](DAX.client.run-application-dotnet.02-Write-Data.md)
+ [03-GetItem-Test.cs](DAX.client.run-application-dotnet.03-GetItem-Test.md)
+ [04-Query-Test.cs](DAX.client.run-application-dotnet.04-Query-Test.md)
+ [05-Scan-Test.cs](DAX.client.run-application-dotnet.05-Scan-Test.md)
+ [06-DeleteTable.cs](DAX.client.run-application-dotnet.06-DeleteTable.md)

# 01-CreateTable.cs
<a name="DAX.client.run-application-dotnet.01-CreateTable"></a>

O programa `01-CreateTable.cs` cria uma tabela (`TryDaxTable`). Os demais programas .NET nesta seção dependem dessa tabela.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            AmazonDynamoDBClient client = new AmazonDynamoDBClient();

            var tableName = "TryDaxTable";

            var request = new CreateTableRequest()
            {
                TableName = tableName,
                KeySchema = new List<KeySchemaElement>()
                {
                    new KeySchemaElement{ AttributeName = "pk",KeyType = "HASH"},
                    new KeySchemaElement{ AttributeName = "sk",KeyType = "RANGE"}
                },
                AttributeDefinitions = new List<AttributeDefinition>() {
                    new AttributeDefinition{ AttributeName = "pk",AttributeType = "N"},
                    new AttributeDefinition{ AttributeName = "sk",AttributeType  = "N"}
                },
                ProvisionedThroughput = new ProvisionedThroughput()
                {
                    ReadCapacityUnits = 10,
                    WriteCapacityUnits = 10
                }
            };

            var response = await client.CreateTableAsync(request);

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 02-Write-Data.cs
<a name="DAX.client.run-application-dotnet.02-Write-Data"></a>

O programa `02-Write-Data.cs` grava dados de teste em `TryDaxTable`.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            AmazonDynamoDBClient client = new AmazonDynamoDBClient();

            var tableName = "TryDaxTable";

            string someData = new string('X', 1000);
            var pkmax = 10;
            var skmax = 10;

            for (var ipk = 1; ipk <= pkmax; ipk++)
            {
                Console.WriteLine($"Writing {skmax} items for partition key: {ipk}");
                for (var isk = 1; isk <= skmax; isk++)
                {
                    var request = new PutItemRequest()
                    {
                        TableName = tableName,
                        Item = new Dictionary<string, AttributeValue>()
                       {
                            { "pk", new AttributeValue{N = ipk.ToString() } },
                            { "sk", new AttributeValue{N = isk.ToString() } },
                            { "someData", new AttributeValue{S = someData } }
                       }
                    };

                    var response = await client.PutItemAsync(request);
                }
            }

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 03-GetItem-Test.cs
<a name="DAX.client.run-application-dotnet.03-GetItem-Test"></a>

O programa `03-GetItem-Test.cs` executa operações `GetItem` em `TryDaxTable`.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            string endpointUri = args[0];
            Console.WriteLine($"Using DAX client - endpointUri={endpointUri}");

            var clientConfig = new DaxClientConfig(endpointUri)
            {
                AwsCredentials = FallbackCredentialsFactory.GetCredentials()
            };
            var client = new ClusterDaxClient(clientConfig);

            var tableName = "TryDaxTable";

            var pk = 1;
            var sk = 10;
            var iterations = 5;

            var startTime = System.DateTime.Now;

            for (var i = 0; i < iterations; i++)
            {
                for (var ipk = 1; ipk <= pk; ipk++)
                {
                    for (var isk = 1; isk <= sk; isk++)
                    {
                        var request = new GetItemRequest()
                        {
                            TableName = tableName,
                            Key = new Dictionary<string, AttributeValue>() {
                            {"pk", new AttributeValue {N = ipk.ToString()} },
                            {"sk", new AttributeValue {N = isk.ToString() } }
                        }
                        };
                        var response = await client.GetItemAsync(request);
                        Console.WriteLine($"GetItem succeeded for pk: {ipk},sk: {isk}");
                    }
                }
            }

            var endTime = DateTime.Now;
            TimeSpan timeSpan = endTime - startTime;
            Console.WriteLine($"Total time: {timeSpan.TotalMilliseconds} milliseconds");

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 04-Query-Test.cs
<a name="DAX.client.run-application-dotnet.04-Query-Test"></a>

O programa `04-Query-Test.cs` executa operações `Query` em `TryDaxTable`.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            string endpointUri = args[0];
            Console.WriteLine($"Using DAX client - endpointUri={endpointUri}");


            var clientConfig = new DaxClientConfig(endpointUri)
            {
                AwsCredentials = FallbackCredentialsFactory.GetCredentials()
            };
            var client = new ClusterDaxClient(clientConfig);

            var tableName = "TryDaxTable";

            var pk = 5;
            var sk1 = 2;
            var sk2 = 9;
            var iterations = 5;

            var startTime = DateTime.Now;

            for (var i = 0; i < iterations; i++)
            {
                var request = new QueryRequest()
                {
                    TableName = tableName,
                    KeyConditionExpression = "pk = :pkval and sk between :skval1 and :skval2",
                    ExpressionAttributeValues = new Dictionary<string, AttributeValue>() {
                            {":pkval", new AttributeValue {N = pk.ToString()} },
                            {":skval1", new AttributeValue {N = sk1.ToString()} },
                            {":skval2", new AttributeValue {N = sk2.ToString()} }
                    }
                };
                var response = await client.QueryAsync(request);
                Console.WriteLine($"{i}: Query succeeded");

            }

            var endTime = DateTime.Now;
            TimeSpan timeSpan = endTime - startTime;
            Console.WriteLine($"Total time: {timeSpan.TotalMilliseconds} milliseconds");

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 05-Scan-Test.cs
<a name="DAX.client.run-application-dotnet.05-Scan-Test"></a>

O programa `05-Scan-Test.cs` executa operações `Scan` em `TryDaxTable`.

```
using System;
using System.Threading.Tasks;
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            string endpointUri = args[0];
            Console.WriteLine($"Using DAX client - endpointUri={endpointUri}");

            var clientConfig = new DaxClientConfig(endpointUri)
            {
                AwsCredentials = FallbackCredentialsFactory.GetCredentials()
            };
            var client = new ClusterDaxClient(clientConfig);

            var tableName = "TryDaxTable";

            var iterations = 5;

            var startTime = DateTime.Now;

            for (var i = 0; i < iterations; i++)
            {
                var request = new ScanRequest()
                {
                    TableName = tableName
                };
                var response = await client.ScanAsync(request);
                Console.WriteLine($"{i}: Scan succeeded");
            }

            var endTime = DateTime.Now;
            TimeSpan timeSpan = endTime - startTime;
            Console.WriteLine($"Total time: {timeSpan.TotalMilliseconds} milliseconds");

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 06-DeleteTable.cs
<a name="DAX.client.run-application-dotnet.06-DeleteTable"></a>

O programa `06-DeleteTable.cs` exclui `TryDaxTable`. Execute esse programa depois de concluir o teste.

```
using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.Model;
using Amazon.DynamoDBv2;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            AmazonDynamoDBClient client = new AmazonDynamoDBClient();

            var tableName = "TryDaxTable";

            var request = new DeleteTableRequest()
            {
                TableName = tableName
            };

            var response = await client.DeleteTableAsync(request);

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# Python e DAX
<a name="DAX.client.run-application-python"></a>

Siga este procedimento para executar a aplicação de exemplo em Python na instância do Amazon EC2.

**Para executar o exemplo de Python para DAX**

1. Instale o cliente do Python do DAX usando o utilitário `pip`.

   ```
   pip install amazon-dax-client
   ```

1. Baixe o código-fonte do programa de exemplo (arquivo `.zip`).

   ```
   wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
   ```

   Quando o download for concluído, extraia os arquivos de origem.

   ```
   unzip TryDax.zip
   ```

1. Execute os seguintes programas do Python. O primeiro programa cria uma tabela do Amazon DynamoDB chamada `TryDaxTable`. O segundo programa grava dados na tabela.

   ```
   python 01-create-table.py
   python 02-write-data.py
   ```

1. Execute os seguintes programas do Python.

   ```
   python 03-getitem-test.py
   python 04-query-test.py
   python 05-scan-test.py
   ```

    Anote as informações de tempo: o número de milissegundos necessários para os testes `GetItem`, `Query` e `Scan`.

1. Na etapa anterior, você executou os programas no endpoint do DynamoDB. Agora execute os programas novamente, mas, desta vez, as operações `GetItem`, `Query` e `Scan` são processadas pelo cluster do DAX.

   Para determinar o endpoint do cluster do DAX, escolha uma das seguintes opções:
   + **Usando o console do DynamoDB**: escolha seu cluster do DAX. O endpoint do cluster é mostrado no console, como no exemplo a seguir.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Usando a AWS CLI**: insira o comando a seguir.

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

     O endpoint do cluster é mostrado na saída, como neste exemplo.

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

   Execute os programas novamente, mas, desta vez, especifique o endpoint do cluster como um parâmetro de linha de comando.

   ```
   python 03-getitem-test.py dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   python 04-query-test.py dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   python 05-scan-test.py dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   ```

   Observe o restante da saída e anote as informações de tempo. Os tempos decorridos para `GetItem`, `Query` e `Scan` devem ser significativamente mais baixos com o DAX do que com o DynamoDB.

1. Execute o seguinte programa do Python para excluir a `TryDaxTable`.

   ```
   python 06-delete-table.py
   ```

Para obter mais informações sobre esses programas, consulte as seguintes seções:
+ [01-create-table.py](DAX.client.run-application-python.01-create-table.md)
+ [02-write-data.py](DAX.client.run-application-python.02-write-data.md)
+ [03-getitem-test.py](DAX.client.run-application-python.03-getitem-test.md)
+ [04-query-test.py](DAX.client.run-application-python.04-query-test.md)
+ [05-scan-test.py](DAX.client.run-application-python.05-scan-test.md)
+ [06-delete-table.py](DAX.client.run-application-python.06-delete-table.md)

# 01-create-table.py
<a name="DAX.client.run-application-python.01-create-table"></a>

O programa `01-create-table.py` cria uma tabela (`TryDaxTable`). Os demais programas Python nesta seção dependem dessa tabela.

```
import boto3


def create_dax_table(dyn_resource=None):
    """
    Creates a DynamoDB table.

    :param dyn_resource: Either a Boto3 or DAX resource.
    :return: The newly created table.
    """
    if dyn_resource is None:
        dyn_resource = boto3.resource("dynamodb")

    table_name = "TryDaxTable"
    params = {
        "TableName": table_name,
        "KeySchema": [
            {"AttributeName": "partition_key", "KeyType": "HASH"},
            {"AttributeName": "sort_key", "KeyType": "RANGE"},
        ],
        "AttributeDefinitions": [
            {"AttributeName": "partition_key", "AttributeType": "N"},
            {"AttributeName": "sort_key", "AttributeType": "N"},
        ],
        "BillingMode": "PAY_PER_REQUEST",
    }
    table = dyn_resource.create_table(**params)
    print(f"Creating {table_name}...")
    table.wait_until_exists()
    return table


if __name__ == "__main__":
    dax_table = create_dax_table()
    print(f"Created table.")
```

# 02-write-data.py
<a name="DAX.client.run-application-python.02-write-data"></a>

O programa `02-write-data.py` grava dados de teste em `TryDaxTable`.

```
import boto3


def write_data_to_dax_table(key_count, item_size, dyn_resource=None):
    """
    Writes test data to the demonstration table.

    :param key_count: The number of partition and sort keys to use to populate the
                      table. The total number of items is key_count * key_count.
    :param item_size: The size of non-key data for each test item.
    :param dyn_resource: Either a Boto3 or DAX resource.
    """
    if dyn_resource is None:
        dyn_resource = boto3.resource("dynamodb")

    table = dyn_resource.Table("TryDaxTable")
    some_data = "X" * item_size

    for partition_key in range(1, key_count + 1):
        for sort_key in range(1, key_count + 1):
            table.put_item(
                Item={
                    "partition_key": partition_key,
                    "sort_key": sort_key,
                    "some_data": some_data,
                }
            )
            print(f"Put item ({partition_key}, {sort_key}) succeeded.")


if __name__ == "__main__":
    write_key_count = 10
    write_item_size = 1000
    print(
        f"Writing {write_key_count*write_key_count} items to the table. "
        f"Each item is {write_item_size} characters."
    )
    write_data_to_dax_table(write_key_count, write_item_size)
```

# 03-getitem-test.py
<a name="DAX.client.run-application-python.03-getitem-test"></a>

O programa `03-getitem-test.py` executa operações `GetItem` em `TryDaxTable`. Este exemplo é fornecido para a região eu-west-1. 

```
import argparse
import sys
import time
import amazondax
import boto3


def get_item_test(key_count, iterations, dyn_resource=None):
    """
    Gets items from the table a specified number of times. The time before the
    first iteration and the time after the last iteration are both captured
    and reported.

    :param key_count: The number of items to get from the table in each iteration.
    :param iterations: The number of iterations to run.
    :param dyn_resource: Either a Boto3 or DAX resource.
    :return: The start and end times of the test.
    """
    if dyn_resource is None:
        dyn_resource = boto3.resource('dynamodb')

    table = dyn_resource.Table('TryDaxTable')
    start = time.perf_counter()
    for _ in range(iterations):
        for partition_key in range(1, key_count + 1):
            for sort_key in range(1, key_count + 1):
                table.get_item(Key={
                    'partition_key': partition_key,
                    'sort_key': sort_key
                })
                print('.', end='')
                sys.stdout.flush()
    print()
    end = time.perf_counter()
    return start, end


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'endpoint_url', nargs='?',
        help="When specified, the DAX cluster endpoint. Otherwise, DAX is not used.")
    args = parser.parse_args()

    test_key_count = 10
    test_iterations = 50
    if args.endpoint_url:
        print(f"Getting each item from the table {test_iterations} times, "
              f"using the DAX client.")
        # Use a with statement so the DAX client closes the cluster after completion.
        with amazondax.AmazonDaxClient.resource(endpoint_url=args.endpoint_url, region_name='eu-west-1') as dax:
            test_start, test_end = get_item_test(
                test_key_count, test_iterations, dyn_resource=dax)
    else:
        print(f"Getting each item from the table {test_iterations} times, "
              f"using the Boto3 client.")
        test_start, test_end = get_item_test(
            test_key_count, test_iterations)
    print(f"Total time: {test_end - test_start:.4f} sec. Average time: "
          f"{(test_end - test_start)/ test_iterations}.")
```

# 04-query-test.py
<a name="DAX.client.run-application-python.04-query-test"></a>

O programa `04-query-test.py` executa operações `Query` em `TryDaxTable`.

```
import argparse
import time
import sys
import amazondax
import boto3
from boto3.dynamodb.conditions import Key


def query_test(partition_key, sort_keys, iterations, dyn_resource=None):
    """
    Queries the table a specified number of times. The time before the
    first iteration and the time after the last iteration are both captured
    and reported.

    :param partition_key: The partition key value to use in the query. The query
                          returns items that have partition keys equal to this value.
    :param sort_keys: The range of sort key values for the query. The query returns
                      items that have sort key values between these two values.
    :param iterations: The number of iterations to run.
    :param dyn_resource: Either a Boto3 or DAX resource.
    :return: The start and end times of the test.
    """
    if dyn_resource is None:
        dyn_resource = boto3.resource("dynamodb")

    table = dyn_resource.Table("TryDaxTable")
    key_condition_expression = Key("partition_key").eq(partition_key) & Key(
        "sort_key"
    ).between(*sort_keys)

    start = time.perf_counter()
    for _ in range(iterations):
        table.query(KeyConditionExpression=key_condition_expression)
        print(".", end="")
        sys.stdout.flush()
    print()
    end = time.perf_counter()
    return start, end


if __name__ == "__main__":
    # pylint: disable=not-context-manager
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "endpoint_url",
        nargs="?",
        help="When specified, the DAX cluster endpoint. Otherwise, DAX is not used.",
    )
    args = parser.parse_args()

    test_partition_key = 5
    test_sort_keys = (2, 9)
    test_iterations = 100
    if args.endpoint_url:
        print(f"Querying the table {test_iterations} times, using the DAX client.")
        # Use a with statement so the DAX client closes the cluster after completion.
        with amazondax.AmazonDaxClient.resource(endpoint_url=args.endpoint_url) as dax:
            test_start, test_end = query_test(
                test_partition_key, test_sort_keys, test_iterations, dyn_resource=dax
            )
    else:
        print(f"Querying the table {test_iterations} times, using the Boto3 client.")
        test_start, test_end = query_test(
            test_partition_key, test_sort_keys, test_iterations
        )

    print(
        f"Total time: {test_end - test_start:.4f} sec. Average time: "
        f"{(test_end - test_start)/test_iterations}."
    )
```

# 05-scan-test.py
<a name="DAX.client.run-application-python.05-scan-test"></a>

O programa `05-scan-test.py` executa operações `Scan` em `TryDaxTable`.

```
import argparse
import time
import sys
import amazondax
import boto3


def scan_test(iterations, dyn_resource=None):
    """
    Scans the table a specified number of times. The time before the
    first iteration and the time after the last iteration are both captured
    and reported.

    :param iterations: The number of iterations to run.
    :param dyn_resource: Either a Boto3 or DAX resource.
    :return: The start and end times of the test.
    """
    if dyn_resource is None:
        dyn_resource = boto3.resource("dynamodb")

    table = dyn_resource.Table("TryDaxTable")
    start = time.perf_counter()
    for _ in range(iterations):
        table.scan()
        print(".", end="")
        sys.stdout.flush()
    print()
    end = time.perf_counter()
    return start, end


if __name__ == "__main__":
    # pylint: disable=not-context-manager
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "endpoint_url",
        nargs="?",
        help="When specified, the DAX cluster endpoint. Otherwise, DAX is not used.",
    )
    args = parser.parse_args()

    test_iterations = 100
    if args.endpoint_url:
        print(f"Scanning the table {test_iterations} times, using the DAX client.")
        # Use a with statement so the DAX client closes the cluster after completion.
        with amazondax.AmazonDaxClient.resource(endpoint_url=args.endpoint_url) as dax:
            test_start, test_end = scan_test(test_iterations, dyn_resource=dax)
    else:
        print(f"Scanning the table {test_iterations} times, using the Boto3 client.")
        test_start, test_end = scan_test(test_iterations)
    print(
        f"Total time: {test_end - test_start:.4f} sec. Average time: "
        f"{(test_end - test_start)/test_iterations}."
    )
```

# 06-delete-table.py
<a name="DAX.client.run-application-python.06-delete-table"></a>

O programa `06-delete-table.py` exclui `TryDaxTable`. Execute esse programa depois de concluir o teste de funcionalidade do Amazon DynamoDB Accelerator (DAX).

```
import boto3


def delete_dax_table(dyn_resource=None):
    """
    Deletes the demonstration table.

    :param dyn_resource: Either a Boto3 or DAX resource.
    """
    if dyn_resource is None:
        dyn_resource = boto3.resource("dynamodb")

    table = dyn_resource.Table("TryDaxTable")
    table.delete()

    print(f"Deleting {table.name}...")
    table.wait_until_not_exists()


if __name__ == "__main__":
    delete_dax_table()
    print("Table deleted!")
```