Migrare dalla versione 2.x alla 3.x del AWS SDK for JavaScript

La AWS SDK for JavaScript versione 3 è una riscrittura importante della versione 2. La sezione descrive le differenze tra le due versioni e spiega come migrare dalla versione 2 alla versione 3 dell'SDK for. JavaScript

Migra il codice su SDK per v3 usando codemod JavaScript

AWS SDK for JavaScript la versione 3 (v3) include interfacce modernizzate per le configurazioni e le utilità dei client, che includono credenziali, caricamento multiparte di Amazon S3, client di documenti DynamoDB, camerieri e altro ancora. Puoi trovare cosa è cambiato nella v2 e nelle versioni equivalenti della v3 per ogni modifica nella guida alla migrazione sul repository. AWS SDK for JavaScript GitHub

Per sfruttare appieno la AWS SDK for JavaScript v3, consigliamo di utilizzare gli script codemod descritti di seguito.

Usa codemod per migrare il codice v2 esistente

La raccolta di script codemod in aws-sdk-js-codemod aiuta a migrare l'applicazione esistente (v2) per utilizzare le API v3. AWS SDK for JavaScript È possibile eseguire la trasformazione come segue.

$ npx aws-sdk-js-codemod -t v2-to-v3 PATH...

Ad esempio, considera di avere il codice seguente, che crea un client Amazon DynamoDB dalla v2 e chiama l'operazione. listTables

// example.ts
import AWS from "aws-sdk";

const region = "us-west-2";
const client = new AWS.DynamoDB({ region });
client.listTables({}, (err, data) => {
  if (err) 
    console.log(err, err.stack);
  else
    console.log(data);
});

Puoi eseguire la nostra v2-to-v3 trasformazione nel modo seguente. example.ts

$ npx aws-sdk-js-codemod -t v2-to-v3 example.ts

La trasformazione convertirà l'importazione di DynamoDB in v3, creerà un client v3 e chiamerà l'operazione come segue. listTables

// example.ts
import { DynamoDB } from "@aws-sdk/client-dynamodb";

const region = "us-west-2";
const client = new DynamoDB({ region });
client.listTables({}, (err, data) => {
  if (err)
    console.log(err, err.stack);
  else
    console.log(data);
});

Abbiamo implementato trasformazioni per casi d'uso comuni. Se il codice non si trasforma correttamente, crea una segnalazione di bug o una richiesta di funzionalità con codice di input di esempio e codice di output osservato/previsto. Se il tuo caso d'uso specifico è già stato segnalato in un problema esistente, mostra il tuo supporto con un voto positivo.

Cosa c'è di nuovo nella versione 3

La versione 3 dell'SDK for JavaScript (v3) contiene le seguenti nuove funzionalità.

Inoltre, l'SDK è integrato, il che presenta molti vantaggi TypeScript, come la digitazione statica.

Pacchetti modularizzati

La versione 2 dell'SDK for JavaScript (v2) richiedeva l'utilizzo dell'intero AWS SDK, come segue.

var AWS = require("aws-sdk");

Il caricamento dell'intero SDK non è un problema se l'applicazione utilizza molti servizi. AWS Tuttavia, se devi utilizzare solo alcuni AWS servizi, significa aumentare le dimensioni dell'applicazione con codice che non ti serve o che non usi.

Nella v3, puoi caricare e utilizzare solo i singoli AWS servizi di cui hai bisogno. Questo è illustrato nell'esempio seguente, che consente di accedere ad Amazon DynamoDB (DynamoDB).

import { DynamoDB } from "@aws-sdk/client-dynamodb";

Non solo puoi caricare e utilizzare singoli AWS servizi, ma puoi anche caricare e utilizzare solo i comandi di servizio necessari. Ciò è illustrato negli esempi seguenti, che consentono di accedere al client DynamoDB e al comando. ListTablesCommand

import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";

import { CognitoIdentity } from "@aws-sdk/client-cognito-identity/CognitoIdentity";

import { CognitoIdentity } from "@aws-sdk/client-cognito-identity";

Confronto delle dimensioni del codice

Nella versione 2 (v2), un semplice esempio di codice che elenca tutte le tabelle Amazon DynamoDB us-west-2 nella regione potrebbe essere simile al seguente.

var AWS = require("aws-sdk");
// Set the Region
AWS.config.update({ region: "us-west-2" });
// Create DynamoDB service object
var ddb = new AWS.DynamoDB({ apiVersion: "2012-08-10" });

// Call DynamoDB to retrieve the list of tables
ddb.listTables({ Limit: 10 }, function (err, data) {
  if (err) {
    console.log("Error", err.code);
  } else {
    console.log("Tables names are ", data.TableNames);
  }
});

v3 ha il seguente aspetto.

import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";

(async function () {
  const dbclient = new DynamoDBClient({ region: 'us-west-2' });

  try {
    const results = await dbclient.send(new ListTablesCommand);
    results.TableNames.forEach(function (item, index) {
      console.log(item);
    });
  } catch (err) {
    console.error(err)
  }
})();

Il aws-sdk pacchetto aggiunge circa 40 MB all'applicazione. La sostituzione var AWS = require("aws-sdk") con import {DynamoDB} from "@aws-sdk/client-dynamodb" riduce tale sovraccarico a circa 3 MB. Limitando l'importazione solo al client ListTablesCommand e al comando DynamoDB si riduce il sovraccarico a meno di 100 KB.

// Load the DynamoDB client and ListTablesCommand command for Node.js
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
const dbclient = new DynamoDBClient({});

Chiamare i comandi nella v3

È possibile eseguire operazioni in v3 utilizzando i comandi v2 o v3. Per utilizzare i comandi v3, è necessario importare i comandi e i client del pacchetto AWS Services richiesti ed eseguire il comando utilizzando il .send metodo utilizzando il modello async/await.

Per utilizzare i comandi v2, importate i pacchetti AWS Services richiesti ed eseguite il comando v2 direttamente nel pacchetto utilizzando un callback o un pattern async/await.

Utilizzo dei comandi v3

v3 fornisce un set di comandi per ogni pacchetto di AWS servizio per consentire all'utente di eseguire operazioni per quel AWS servizio. Dopo aver installato un AWS servizio, puoi sfogliare i comandi disponibili nel tuo progetto node-modules/@aws-sdk/client-PACKAGE_NAME/commands folder.

È necessario importare i comandi che si desidera utilizzare. Ad esempio, il codice seguente carica il servizio DynamoDB e il comando. CreateTableCommand

import { DynamoDB, CreateTableCommand } from "@aws-sdk/client-dynamodb";

Per chiamare questi comandi nel modello async/await consigliato, utilizzate la seguente sintassi.

CLIENT.send(new XXXCommand);

Ad esempio, l'esempio seguente crea una tabella DynamoDB utilizzando il pattern async/await consigliato.

import { DynamoDB, CreateTableCommand } from "@aws-sdk/client-dynamodb";
const dynamodb = new DynamoDB({ region: 'us-west-2' });
var tableParams = {
  Table: TABLE_NAME
};
(async function () => {
  try {
    const data = await dynamodb.send(new CreateTableCommand(tableParams));
    console.log("Success", data);
  }
  catch (err) {
    console.log("Error", err);
  }
}) ();

Utilizzo dei comandi v2

Per utilizzare i comandi v2 nell'SDK for JavaScript, è necessario importare i pacchetti di AWS servizio completi, come illustrato nel codice seguente.

const { DynamoDB } = require('@aws-sdk/client-dynamodb');

Per chiamare i comandi v2 nel pattern async/await consigliato, utilizzate la seguente sintassi.

client.command(parameters);

L'esempio seguente utilizza il createTable comando v2 per creare una tabella DynamoDB utilizzando il pattern async/await consigliato.

const { DynamoDB } = require('@aws-sdk/client-dynamodb');
const dynamoDB = new DynamoDB({ region: 'us-west-2' });
var tableParams = {
  TableName: TABLE_NAME
};
async function run() => {
  try {
    const data = await dynamoDB.createTable(tableParams);
    console.log("Success", data);
  }
  catch (err) {
    console.log("Error", err);
  }
};
run();

L'esempio seguente utilizza il createBucket comando v2 per creare un bucket Amazon S3 utilizzando il pattern di callback.

const { S3 } = require('@aws-sdk/client-s3');
const s3 = new S3({ region: 'us-west-2' });
var bucketParams = {
  Bucket : BUCKET_NAME
};
function run() {
  s3.createBucket(bucketParams, function (err, data) {
    if (err) {
      console.log("Error", err);
    } else {
      console.log("Success", data.Location);
    }
  })
};
run();

Nuovo stack di middleware

la v2 dell'SDK consentiva di modificare una richiesta durante le diverse fasi del suo ciclo di vita collegando listener di eventi alla richiesta. Questo approccio può rendere difficile il debug di ciò che è andato storto durante il ciclo di vita di una richiesta.

Nella v3, è possibile utilizzare un nuovo stack middleware per controllare il ciclo di vita di una chiamata operativa. Questo approccio offre un paio di vantaggi. Ogni fase del middleware dello stack chiama la fase middleware successiva dopo aver apportato modifiche all'oggetto della richiesta. Ciò semplifica notevolmente anche i problemi di debug nello stack, poiché è possibile vedere esattamente quali fasi del middleware sono state chiamate prima dell'errore.

L'esempio seguente aggiunge un'intestazione personalizzata a un client Amazon DynamoDB (che abbiamo creato e mostrato in precedenza) utilizzando il middleware. Il primo argomento è una funzione che accettanext, che è la fase successiva del middleware dello stack da chiamarecontext, e che è un oggetto che contiene alcune informazioni sull'operazione chiamata. La funzione restituisce una funzione che accettaargs, ovvero un oggetto che contiene i parametri passati all'operazione e alla richiesta. Restituisce il risultato della chiamata al middleware successivo con. args

dbclient.middlewareStack.add(
  (next, context) => args => {
    args.request.headers["Custom-Header"] = "value";
    return next(args);
  },
  {
    step: "build"
  }
);  

dbclient.send(new PutObjectCommand(params));