Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Fase 4: esecuzione di una applicazione di esempio
Per semplificare il test della funzionalità Amazon DynamoDB Accelerator (DAX), è possibile eseguire le applicazioni di esempio disponibili sull'istanza Amazon EC2.
**Topics**
+ [Node.js e DAX](DAX.client.run-application-nodejs-3.md)
+ [SDK per Go di DAX](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
# Configurazione di un client predefinito per Node.js
Durante la configurazione del client DAX JavaScript SDK, è possibile personalizzare vari parametri per ottimizzare le prestazioni, la gestione della connessione e la resilienza agli errori. La tabella seguente descrive le impostazioni di configurazione predefinite che controllano il modo in cui il client interagisce con il cluster DAX, inclusi i valori di timeout, i meccanismi di ripetizione dei tentativi, la gestione delle credenziali e le opzioni di monitoraggio dello stato. [Per ulteriori informazioni, consulta Dynamo Operations. DBClient ](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/)
**Impostazioni predefinite del client SDK DAX per JS**
| Parametro | Tipo | Description |
| --- | --- | --- |
| `region` facoltativo | `string` | Regione AWS Da usare per il client DAX (esempio: 'us-east-1'). Questo è un parametro obbligatorio se non viene fornito tramite la variabile di ambiente. |
| `endpoint` obbligatorio | `string` | L’endpoint del Cluster a cui si connette l’SDK. Esempi: Non crittografato: .region.amazonaws.com dax-cluster-name Crittografato: daxs://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com |
| `requestTimeout` valore predefinito 6000 ms | `number` | Definisce il tempo massimo di attesa da parte del client per ricevere una risposta da DAX. |
| `writeRetries` valore predefinito 1 | `number` | Il numero di ripetizioni di tentativi per le richieste di scrittura che hanno esito negativo. |
| `readRetries` valore predefinito 1 | `number` | Il numero di ripetizioni di tentativi per le richieste di lettura che hanno esito negativo. |
| `maxRetries` valore predefinito 1 | `number` | Il numero massimo di ripetizioni di tentativi in caso di richieste che hanno esito negativo. Se readRetries/writeRetries sono impostati, la configurazione impostata in readRetries e writeRetries ha la priorità su maxRetries. |
| `connectTimeout` valore predefinito 10000 ms | `number` | Il timeout (in millisecondi) per stabilire una connessione a uno qualsiasi dei nodi del cluster. |
| `maxConcurrentConnections` valore predefinito 100 | `number` | Limita il numero totale di connessioni simultanee che un’istanza client può creare per nodo in un cluster DAX. |
| `maxRetryDelay` valore predefinito 7000 ms | `number` | Quando il server DAX indica che è necessario il ripristino impostando il flag `waitForRecoveryBeforeRetrying` su true, il client si interrompe prima della ripetizione del tentativo. Durante questi periodi di recupero, il parametro `maxRetryDelay` determina il tempo massimo di attesa tra le ripetizioni di tentativi. Questa configurazione specifica per il recupero si applica solo quando il server DAX è in modalità di recupero. In tutti gli altri scenari, il comportamento delle ripetizioni di tentativi segue uno dei due modelli seguenti: un ritardo esponenziale basato sul numero di ripetizioni di tentativi (regolato da parametri `writeRetries`, `readRetries` o `maxRetries`) o una ripetizione di tentativo immediata a seconda del tipo di eccezione. |
| `credentials` facoltativo | `[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/)` | Le credenziali da utilizzare per l'autenticazione delle richieste. AWS Questo può essere fornito come un o un AwsCredentialIdentity . AwsCredentialIdentityProvider Se non fornite, l’SDK AWS utilizzerà automaticamente la catena di provider di credenziali predefinita. Esempio: `\$1 accessKeyId: 'AKIA... ' , secretAccessKey: ' ... ', sessionToken:'... '\$1 `\$1 @default Utilizza la catena di provider di credenziali AWS predefinita. |
| `healthCheckInterval` valore predefinito 5000 ms | `number` | L’intervallo (in millisecondi) tra i controlli di integrità del cluster. Un intervallo più basso verrà controllato più frequentemente. |
| `healthCheckTimeout` valore predefinito 1000 ms | `number` | Il timeout (in millisecondi) per il completamento del controllo dell’integrità. |
| `skipHostnameVerification` valore predefinito false | `boolean` | Salta la verifica del nome host delle connessioni TLS. Non ha alcun impatto sui cluster non crittografati. L’impostazione predefinita prevede la verifica del nome host; impostandola su True, la verifica verrà saltata. Assicurati di comprendere le implicazioni della disattivazione, ovvero l’impossibilità di autenticare il cluster a cui ti stai connettendo. |
| `unhealthyConsecutiveErrorCount` valore predefinito 5 | `number` | Imposta il numero di errori consecutivi necessari per segnalare un nodo non integro entro l’intervallo di controllo dell’integrità. |
| `clusterUpdateInterval` valore predefinito 4000 ms | `number` | Restituisce l’intervallo tra polling di membri del cluster per le modifiche ai membri del cluster. |
| `clusterUpdateThreshold` valore predefinito 125 | `number` | Restituisce la soglia al di sotto della quale sul cluster non verranno eseguite query per le modifiche ai membri. |
| `credentailProvider` opzionale \$1 valore predefinito null | `[AwsCredentialIdentityProvider](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/)` | Provider definito dall'utente per AWS le credenziali utilizzate per autenticare le richieste a DAX. |
**Configurazione della paginazione per DaxDocument**
| Name | Tipo | Dettaglio |
| --- | --- | --- |
| `client` | DaxDocument | Istanza di DaxDocument tipo. |
| `pageSize` | numero | Determina il numero di elementi per pagina. |
| `startingToken` Facoltativo | any | LastEvaluatedKey dalla risposta precedente può essere utilizzato per richieste successive. |
Per l’utilizzo dell’impaginazione, consulta [TryDax.js](DAX.client.tutorial-TryDax.md).
# Migrazione a SDK DAX per Node.js V3
Questa guida alla migrazione aiuterà a effettuare la transizione delle applicazioni Node.js esistenti con DAX. Il nuovo SDK richiede Node.js 18 o versione successiva e introduce diverse importanti modifiche alla struttura del codice di DynamoDB Accelerator. Questa guida illustrerà le differenze principali, tra cui modifiche alla sintassi, nuovi metodi di importazione e modelli di programmazione asincrona aggiornati.
## Utilizzo di DAX per V2 Node.js
```
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);
}
});
```
## Utilizzo di DAX per V3 Node.js
Per l’utilizzo di DAX per Node.js V3, Node versione 18 o successiva è la versione preferita. Per passare a Node 18, utilizza quanto segue:
```
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);
}
```
L’SDK DAX per Node.js v3.x è compatibile con [SDK AWS per Node.js v3.x](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/). L’SDK DAX per Node.js v3.x supporta l’uso di client [aggregati](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/#high-level-concepts). Si noti che DAX non supporta la creazione di client essenziali (bare-bones). Per ulteriori informazioni sulle funzionalità non supportate, consulta [Funzionalità non in parità con AWS SDK V3](#DAX.client.run-application-nodejs-3-not-in-parity).
Completare questa procedura per eseguire l'applicazione di esempio Node.js sull'istanza Amazon EC2.
**Come eseguire l'applicazione di esempio Node.js per DAX**
1. Configurare Node.js nell'istanza Amazon EC2 come segue:
1. Installa il gestore delle versioni del nodo (`nvm`).
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
```
1. Usa nvm per installare Node.js.
```
nvm install 18
```
1. Usa nvm per utilizzare Node 18
```
nvm use 18
```
1. Verifica che Node.js sia installato e funzioni correttamente.
```
node -e "console.log('Running Node.js ' + process.version)"
```
Si dovrebbe visualizzare il seguente messaggio.
`Running Node.js v18.x.x`
1. Installa il client DaxDocument Node.js utilizzando il gestore di pacchetti del nodo (`npm`).
```
npm install @amazon-dax-sdk/lib-dax
```
## TryDax codice di esempio
Per valutare i vantaggi prestazionali di DynamoDB Accelerator (DAX), segui questa procedura per eseguire un test di esempio che confronta i tempi di lettura tra DynamoDB standard e un cluster DAX.
1. Dopo aver configurato il workspace e installato `lib-dax` come dipendenza, copia [TryDax.js](DAX.client.tutorial-TryDax.md) nel progetto.
1. Esegui il programma sul cluster DAX. Per determinare l'endpoint per il cluster DAX, scegli una delle seguenti opzioni:
+ **Utilizzo della console DynamoDB**: scegli il cluster DAX. L'endpoint del cluster viene visualizzato nella console, come nell'esempio seguente.
```
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```
+ **Utilizzando il** comando AWS CLI— Immettere il seguente comando.
```
aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
```
L'endpoint del cluster viene visualizzato nell'output, come nell'esempio seguente.
```
{
"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. Ora esegui il programma, specificando l’endpoint del cluster come parametro della riga di comando.
```
node TryDax.js dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```
Verrà visualizzato un output simile al seguente:
```
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.
```
Prendi nota delle informazioni sui tempi. Il numero di microsecondi necessari per i test `GetItem`, `Query`, `Scan`.
1. In questo caso, i programmi sono stati eseguiti sul cluster DAX. Ora eseguirai di nuovo il programma, questa volta su DynamoDB.
1. A questo punto, esegui di nuovo il programma, ma questa volta senza l’URL dell’endpoint del cluster come parametro della riga di comando.
```
node TryDax.js
```
Consultare l'output e prendere nota delle informazioni sui tempi. I tempi trascorsi per `GetItem`, `Query` e `Scan` devono essere significativamente più bassi con DAX rispetto a DynamoDB.
## Funzionalità non in parità con AWS SDK V3
+ Client [essenziali](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/#high-level-concepts): Dax per Node.js V3 non supporta client essenziali.
```
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);
```
+ [Stack middleware](https://aws.amazon.com/blogs/developer/middleware-stack-modular-aws-sdk-js/): Dax per Node.js V3 non supporta l’utilizzo di funzioni 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
```
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();
})();
```
# SDK per Go di DAX
Seguire questa procedura per eseguire l'applicazione di esempio SDK per Go per Amazon DynamoDB Accelerator (DAX) sull'istanza Amazon EC2.
**Come eseguire l'esempio SDK per Go per DAX**
1. Configurare l'SDK for Go sull'istanza Amazon EC2:
1. Installa il linguaggio di programmazione Go (`Golang`).
```
sudo yum install -y golang
```
1. Verifica che Golang sia installata e funzioni correttamente.
```
go version
```
Dovrebbe apparire un messaggio come questo.
```
go version go1.23.4 linux/amd64
```
1. Installa l'applicazione Golang di esempio.
```
go get github.com/aws-samples/sample-aws-dax-go-v2
```
1. Esegui i seguenti programmi Golang. Il primo programma crea una tabella DynamoDB denominata `TryDaxGoTable`. Il secondo programma scrive i dati nella tabella.
```
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. Esegui i seguenti programmi 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
```
Prendi nota delle informazioni sui tempi: il numero di millisecondi richiesto per i test `GetItem`, `Query` e `Scan`.
1. Nella fase precedente, i programmi sono stati eseguiti sull'endpoint DynamoDB. A questo punto, eseguire nuovamente i programmi, ma questa volta le operazioni `GetItem`, `Query` e `Scan` saranno elaborate dal cluster DAX.
Per determinare l'endpoint per il cluster DAX, scegli una delle seguenti opzioni:
+ **Utilizzo della console DynamoDB**: scegli il cluster DAX. L'endpoint del cluster viene visualizzato nella console, come nell'esempio seguente.
```
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```
+ **Utilizzando il AWS CLI** — Immettere il seguente comando.
```
aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
```
L'endpoint del cluster viene visualizzato nell'output, come nell'esempio seguente.
```
{
"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"
}
```
Ora esegui di nuovo i programmi, ma questa volta specifica l'endpoint del cluster come parametro della riga di 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
```
Guarda il resto dell'output e prendi nota delle informazioni sui tempi. I tempi trascorsi per `GetItem`, `Query` e `Scan` devono essere significativamente più bassi con DAX che con DynamoDB.
1. Esegui il seguente programma Golang per eliminare `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
```
## Funzionalità non in parità con la versione 2 AWS SDK per Go
Middleware Stack: DAX Go V2 non supporta l'uso di Middleware Stacks tramite. APIoptions [Per ulteriori informazioni, consulta Personalizzazione delle richieste client v2 con Middleware. AWS SDK per Go](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)
Esempio:
```
// 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
}
```
Output:
```
failed to execute command: custom middleware through APIOptions is not supported in DAX client
exit status 1
```
# Configurazione di un client predefinito per Go
In questa guida verranno illustrate le opzioni di configurazione che consentono di ottimizzare le prestazioni, la gestione delle connessioni e il comportamento di registrazione di log del client DAX. Comprendendo le impostazioni predefinite e come personalizzarle è possibile ottimizzare l’interazione dell’applicazione Go con DAX.
**Topics**
+ [Impostazioni predefinite del client SDK DAX per Go](#DAX-client-config-Go-sdk-client-defaults)
+ [Creazione di client](#DAX-client-config-Go-client-creation)
## Impostazioni predefinite del client SDK DAX per Go
| Parametro | Tipo | Description |
| --- | --- | --- |
| `Region` obbligatorio | `string` | Regione AWS Da usare per il client DAX (esempio: 'us-east-1'). Questo è un parametro obbligatorio se non viene fornito tramite l’ambiente. |
| `HostPorts` obbligatorio | `[] string` | Elenco degli endpoint del cluster DAX a cui si connette l’SDK. Esempio: Non crittografato: dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com Crittografato: daxs://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com |
| `MaxPendingConnectionsPerHost` valore predefinito 10 | `number` | Numero di tentativi di connessione concomitanti. (È possibile che le connessioni siano in fase di creazione simultanea.) |
| `ClusterUpdateThreshold` valore predefinito 125 \$1 time.Millisecond | `time.Duration` | Il tempo minimo che deve trascorrere tra gli aggiornamenti del cluster. |
| `ClusterUpdateInterval` valore predefinito 4 \$1 time.Second | `time.Duration` | L’intervallo con cui il client aggiornerà automaticamente le informazioni del cluster DAX. |
| `IdleConnectionsReapDelay` valore predefinito 30 \$1 time.Second | `time.Duration` | L’intervallo in base al quale il client chiuderà le connessioni inattive nel client DAX. |
| `ClientHealthCheckInterval` valore predefinito 5 \$1 time.Second | `time.Duration` | L’intervallo con cui il client eseguirà i controlli di integrità sugli endpoint del cluster DAX. |
| `Credentials` default | `aws.CredentialsProvider` | Le AWS credenziali utilizzate dal client DAX per autenticare le richieste al servizio DAX. Consulta [Credentials and Credential Providers](https://docs.aws.amazon.com/sdk-for-go/v2/developer-guide/migrate-gosdk.html#credentials--credential-providers). |
| `DialContext` default | `func` | Una funzione personalizzata utilizzata dal client DAX per stabilire connessioni al cluster DAX. |
| `SkipHostnameVerification` valore predefinito false | bool | Salta la verifica del nome host delle connessioni TLS. Questa impostazione ha effetto solo sui cluster crittografati. Se impostata su True, disabilita la verifica del nome host. La disabilitazione della verifica significa che non è possibile autenticare l’identità del cluster a cui si sta effettuando la connessione, il che comporta rischi per la sicurezza. Per impostazione predefinita, la verifica del nome host è abilitata. |
| `RouteManagerEnabled` valore predefinito false | `bool` | Questo flag viene utilizzato per rimuovere gli instradamenti soggetti a errori di rete. |
| `RequestTimeout` valore predefinito 60 \$1 time.Second | `time.Duration` | Definisce il tempo massimo di attesa da parte del client per ricevere una risposta da DAX. Priorità: timeout contestuale (se impostato) > `RequestTimmeout` (se impostato) > Valore predefinito 60 s `RequestTimeout`. |
| `WriteRetries` valore predefinito 2 | `number` | Il numero di ripetizioni di tentativi per le richieste di scrittura che hanno esito negativo. |
| `ReadRetries` valore predefinito 2 | `number` | Il numero di ripetizioni di tentativi per le richieste di lettura che hanno esito negativo. |
| `RetryDelay` valore predefinito 0 | `time.Duration` | Il ritardo per gli errori non sottoposti a limitazione (della larghezza di banda della rete) (in secondi) per le ripetizioni di tentativi quando una richiesta ha esito negativo. |
| `Logger` facoltativo | `logging.Logger` | Logger è un’interfaccia per la registrazione di log delle voci in determinate classificazioni. |
| `LogLevel` utilità predefinite. LogOff | `number` | Questo loglevel è definito solo per DAX. Può essere importato usando [github. com/aws/aws-dax-go-v2/tree/main/dax/utils](https://github.com/aws/aws-dax-go-v2/tree/main/dax/utils). const (
LogOff LogLevelType = 0
LogDebug LogLevelType = 1
LogDebugWithRequestRetries
LogLevelType = 2
)
|
**Nota**
Per `time.Duration`, l’unità predefinita è il nanosecondo. Se non si specifica alcuna unità per un parametro, verranno utilizzati i nano secondi: `daxCfg.ClusterUpdateInterval = 10` significa 10 nano secondi. (`daxCfg.ClusterUpdateInterval = 10 * time.Millisecond` significa 10 millisecondi).
## Creazione di client
**Come creare un client DAX:**
+ Crea la configurazione DAX, quindi crea il client DAX utilizzando la configurazione DAX. In questo modo è possibile sovrascrivere una configurazione DAX, se necessario.
```
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)
```
# Migrazione a SDK DAX per Go V2
Questa guida alla migrazione aiuterà a effettuare la transizione delle applicazioni DAX per Go esistenti.
## Utilizzo dell’SDK DAX per Go V1
```
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)
}
```
## Utilizzo dell’SDK DAX per Go V2
```
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)
}
```
Per ulteriori dettagli ed esempi di API, consulta [AWS samples](https://github.com/aws-samples/sample-aws-dax-go-v2).
# Java e DAX
SDK per Java 2.x per DAX è compatibile con [AWS SDK per Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/). È basato su Java 8\$1 e include il supporto per I/O non bloccanti. Per informazioni sull'utilizzo di DAX con SDK for AWS Java 1.x, consulta. [Uso di DAX con AWS SDK per Java 1.x](DAX.client.java-sdk-v1.md)
## Utilizzo del client come dipendenza Maven
Segui queste fasi per utilizzare il client per l'SDK DAX per Java nella tua applicazione come una dipendenza:
1. Scarica e installa Apache Maven. Per ulteriori informazioni, consulta le pagine relative al [download di Apache Maven](https://maven.apache.org/download.cgi) e all'[installazione di Apache Maven](https://maven.apache.org/install.html).
1. Aggiungi la dipendenza Maven client al file POM (Project Object Model) dell'applicazione. In questo esempio, sostituiscilo *x.x.x* con il numero di versione effettivo del client.
```
software.amazon.dax
amazon-dax-client
x.x.x
```
## TryDax codice di esempio
Dopo aver configurato il workspace e aggiunto l'SDK DAX come dipendenza, copiare [TryDax.java](DAX.client.TryDax.java.md) nel progetto.
Eseguire il codice utilizzando questo comando.
```
java -cp classpath TryDax
```
Verrà visualizzato un output simile al seguente.
```
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.
```
Prendi nota delle informazioni sui tempi: il numero di millisecondi richiesto per i test `GetItem` e `Query`. In questo caso, il programma è stato eseguito sull'endpoint DynamoDB. Ora eseguirai di nuovo il programma, questa volta rispetto al cluster DAX.
Per determinare l'endpoint per il cluster DAX, scegli una delle seguenti opzioni:
+ Nella console DynamoDB, seleziona il cluster DAX. L'endpoint del cluster viene visualizzato nella console, come nell'esempio seguente.
```
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```
+ Usando AWS CLI, inserisci il seguente comando:
```
aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
```
L'indirizzo, la porta e l'URL dell'endpoint del cluster vengono visualizzati nell'output, come nell'esempio seguente.
```
{
"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"
}
```
A questo punto, eseguire di nuovo il programma, ma questa volta specificare l'endpoint del cluster come parametro della riga di comando.
```
java -cp classpath TryDax dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```
Consultare l'output e prendere nota delle informazioni sui tempi. I tempi trascorsi per `GetItem` e `Query` devono essere significativamente più bassi con DAX che con DynamoDB.
## Parametri SDK
Con DAX SDK for Java 2.x, puoi raccogliere metriche sui client di servizio nella tua applicazione e analizzare l'output in Amazon. CloudWatch Per ulteriori informazioni, consulta [Abilitazione dei parametri SDK](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/metrics.html).
**Nota**
L'SDK DAX per Java raccoglie solo le metriche `ApiCallSuccessful` e `ApiCallDuration`.
# TryDax.java
```
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
Completare questa procedura per eseguire l'applicazione di esempio .NET sull'istanza Amazon EC2.
**Nota**
Questo tutorial utilizza l'SDK.NET 9. Mostra come eseguire un programma nell'Amazon VPC predefinito per accedere al cluster Amazon DynamoDB Accelerator (DAX). Funziona con l'[AWS SDK v4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html) per.NET. Per dettagli sulle modifiche alla V4 e informazioni sulla migrazione, consulta [Migrazione alla versione 4 dell'SDK for AWS .NET](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html). Se preferisci, puoi usare il AWS Toolkit for Visual Studio per scrivere un'applicazione.NET e distribuirla nel tuo VPC.
Per ulteriori informazioni, consulta [Creazione e implementazione di applicazioni Elastic Beanstalk in .NET mediante AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_NET.html) nella *Guida per gli sviluppatori di AWS Elastic Beanstalk *.
**Come eseguire l'applicazione di esempio .NET per DAX**
1. Vai alla [pagina Microsoft Downloads](https://www.microsoft.com/net/download?initial-os=linux) e scarica l'ultima versione di.NET 9 SDK per Linux. Il file scaricato è `dotnet-sdk-N.N.N-linux-x64.tar.gz`.
1. Estrai i file SDK.
```
mkdir dotnet
tar zxvf dotnet-sdk-N.N.N-linux-x64.tar.gz -C dotnet
```
Sostituisci `N.N.N` con il numero effettivo della versione dell'SDK .NET (ad esempio: `9.0.305`).
1. Verifica l'installazione.
```
alias dotnet=$HOME/dotnet/dotnet
dotnet --version
```
Ciò dovrebbe stampare il numero di versione dell'SDK .NET.
**Nota**
Invece del numero di versione, potresti ricevere l'errore seguente:
error: libunwind.so.8: cannot open shared object file: No such file or directory
Per risolvere l'errore, installa il pacchetto `libunwind`.
```
sudo yum install -y libunwind
```
Dopo aver eseguito questa operazione, dovresti essere in grado di eseguire il comando `dotnet --version` senza errori.
1. Crea un nuovo progetto .NET.
```
dotnet new console -o myApp
```
Questa operazione richiede alcuni minuti per eseguire una one-time-only configurazione. Al termine, esegui il progetto di esempio.
```
dotnet run --project myApp
```
Dovresti ricevere il seguente messaggio: `Hello World!`
1. Il file `myApp/myApp.csproj` contiene metadati sul tuo progetto. Per utilizzare il client DAX nell'applicazione, modificare il file nel modo seguente.
```
Exe
net9.0
```
1. Scarica il codice sorgente del programma di esempio (file `.zip`).
```
wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
```
Al termine del download, estrai i file di origine.
```
unzip TryDax.zip
```
1. Ora esegui i programmi di esempio di *dotNet*, uno alla volta. Per ogni programma, copia i suoi contenuti in `myApp/Program.cs` ed esegui il progetto `MyApp`.
Esegui i seguenti programmi .NET. Il primo programma crea una tabella DynamoDB denominata `TryDaxTable`. Il secondo programma scrive i dati nella tabella.
```
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. Quindi, avviare alcuni programmi per eseguire le operazioni `GetItem`, `Query` e `Scan` sul cluster DAX. Per determinare l'endpoint per il cluster DAX, scegli una delle seguenti opzioni:
+ **Utilizzo della console DynamoDB**: scegli il cluster DAX. L'endpoint del cluster viene visualizzato nella console, come nell'esempio seguente.
```
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```
+ **Utilizzando il AWS CLI** — Immettere il seguente comando.
```
aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
```
L'endpoint del cluster viene visualizzato nell'output, come nell'esempio seguente.
```
{
"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"
}
```
Ora esegui i seguenti programmi, specificando il tuo endpoint del cluster come parametro della riga di comando. Sostituisci l'endpoint di esempio con l'endpoint del cluster DAX.
```
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
```
Prendi nota delle informazioni sui tempi: il numero di millisecondi richiesto per i test `GetItem`, `Query` e `Scan`.
1. Esegui il seguente programma .NET per eliminare `TryDaxTable`:
```
cp TryDax/dotNet/06-DeleteTable.cs myApp/Program.cs
dotnet run --project myApp
```
Per ulteriori informazioni sui programmi, consulta le seguenti sezioni:
+ [0-1 csCreateTable.](DAX.client.run-application-dotnet.01-CreateTable.md)
+ [02-Write-Data.cs](DAX.client.run-application-dotnet.02-Write-Data.md)
+ [03- -Test.cs GetItem](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)
+ [DeleteTable0-6 pezzi](DAX.client.run-application-dotnet.06-DeleteTable.md)
# 0-1 csCreateTable.
Il programma `01-CreateTable.cs` crea una tabella (`TryDaxTable`). I programmi .NET rimanenti in questa sezione dipendono da questa tabella.
```
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()
{
new KeySchemaElement{ AttributeName = "pk",KeyType = "HASH"},
new KeySchemaElement{ AttributeName = "sk",KeyType = "RANGE"}
},
AttributeDefinitions = new List() {
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 to continue...");
Console.ReadLine();
}
}
}
```
# 02-Write-Data.cs
Il programma `02-Write-Data.cs` scrive i dati di test in `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()
{
{ "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 to continue...");
Console.ReadLine();
}
}
}
```
# 03- -Test.cs GetItem
Il programma `03-GetItem-Test.cs` esegue le operazioni `GetItem` in `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() {
{"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 to continue...");
Console.ReadLine();
}
}
}
```
# 04-Query-Test.cs
Il programma `04-Query-Test.cs` esegue le operazioni `Query` in `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() {
{":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 to continue...");
Console.ReadLine();
}
}
}
```
# 05-Scan-Test.cs
Il programma `05-Scan-Test.cs` esegue le operazioni `Scan` in `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 to continue...");
Console.ReadLine();
}
}
}
```
# DeleteTable0-6 pezzi
Il programma `06-DeleteTable.cs` elimina `TryDaxTable`. Esegui questo programma dopo aver completato i test.
```
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 to continue...");
Console.ReadLine();
}
}
}
```
# Python e DAX
Completare questa procedura per eseguire l'applicazione di esempio Python sull'istanza Amazon EC2.
**Come eseguire l'applicazione di esempio Python per DAX**
1. Installare il client Python per DAX mediante l'utilità `pip`.
```
pip install amazon-dax-client
```
1. Scarica il codice sorgente del programma di esempio (file `.zip`).
```
wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
```
Al termine del download, estrai i file di origine.
```
unzip TryDax.zip
```
1. Esegui i seguenti programmi Python. Il primo programma crea una tabella Amazon DynamoDB denominata `TryDaxTable`. Il secondo programma scrive i dati nella tabella.
```
python 01-create-table.py
python 02-write-data.py
```
1. Esegui i seguenti programmi Python.
```
python 03-getitem-test.py
python 04-query-test.py
python 05-scan-test.py
```
Prendi nota delle informazioni sui tempi: il numero di millisecondi richiesto per i test `GetItem`, `Query` e `Scan`.
1. Nella fase precedente, i programmi sono stati eseguiti sull'endpoint DynamoDB. A questo punto, eseguire nuovamente i programmi, ma questa volta le operazioni `GetItem`, `Query` e `Scan` saranno elaborate dal cluster DAX.
Per determinare l'endpoint per il cluster DAX, scegli una delle seguenti opzioni:
+ **Utilizzo della console DynamoDB**: scegli il cluster DAX. L'endpoint del cluster viene visualizzato nella console, come nell'esempio seguente.
```
dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
```
+ **Utilizzando il AWS CLI** — Immettere il seguente comando.
```
aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
```
L'endpoint del cluster viene visualizzato nell'output, come in questo esempio.
```
{
"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"
}
```
Esegui nuovamente i programmi, ma questa volta specifica l'endpoint del cluster come parametro della riga di 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
```
Guarda il resto dell'output e prendi nota delle informazioni sui tempi. I tempi trascorsi per `GetItem`, `Query` e `Scan` devono essere significativamente più bassi con DAX che con DynamoDB.
1. Esegui il seguente programma Python per eliminare `TryDaxTable`.
```
python 06-delete-table.py
```
Per ulteriori informazioni sui programmi, consulta le seguenti sezioni:
+ [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
Il programma `01-create-table.py` crea una tabella (`TryDaxTable`). I programmi Python rimanenti in questa sezione dipendono da questa tabella.
```
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
Il programma `02-write-data.py` scrive i dati di test in `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
Il programma `03-getitem-test.py` esegue le operazioni `GetItem` in `TryDaxTable`. Questo esempio è fornito per la Regione 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
Il programma `04-query-test.py` esegue le operazioni `Query` in `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
Il programma `05-scan-test.py` esegue le operazioni `Scan` in `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
Il programma `06-delete-table.py` elimina `TryDaxTable`. Eseguire questo programma dopo aver completato i test della funzionalità 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!")
```