Membuat Rest Api Dengan Nodejs Menggunakan DynamoDB
Node umumnya digunakan dengan MongoDB di tumpukan MEAN. Namun, menggunakan DynamoDB Amazon memiliki kelebihannya sendiri, terutama kecepatan, skalabilitas, keterjangkauan, dan membebaskan waktu dari mengonfigurasi klaster/pembaruan database. Artikel ini menjelaskan cara menyiapkan DynamoDB di proyek Node lokal Anda.
Versi
- Node 9.2.1
- Ekspres 4.15.5
- DynamoDB lokal—terbaru
- JRE (Java Runtime Environment) 6.x atau lebih tinggi
Menyiapkan proyek Node
Agar segala sesuatunya berjalan dengan cepat, gunakan generator ekspres untuk merancah proyek Anda.
#bash$ express node-dynamo-db
create : node-dynamo-db
create : node-dynamo-db/package.json
create : node-dynamo-db/app.js
create : node-dynamo-db/public
create : node-dynamo-db/routes
create : node-dynamo-db/routes/index.js
create : node-dynamo-db/routes/users.js
create : node-dynamo-db/views
create : node-dynamo-db/views/index.jade
create : node-dynamo-db/views/layout.jade
create : node-dynamo-db/views/error.jade
create : node-dynamo-db/bin
create : node-dynamo-db/bin/www
create : node-dynamo-db/public/javascripts
create : node-dynamo-db/public/images
create : node-dynamo-db/public/stylesheets
create : node-dynamo-db/public/stylesheets/style.cssinstall dependencies:
$ cd node-dynamo-db && npm installrun the app:
$ DEBUG=node-dynamo-db:* npm start$ cd node-dynamo-db
$ npm install
Mulai server untuk memastikan semuanya berfungsi sebagaimana mestinya.
$ npm start
Buka http://localhost:3000 dan Anda akan melihat halaman sambutan Express seperti ini:
Kemudian, karena tidak ada reload langsung, kami menginstal Nodemon untuk melihat file dan memulai ulang server setiap kali ada perubahan. Tanpa Nodemon, dengan cepat menjadi frustasi. Setelah diinstal, perbarui perintah mulai di package.json Anda untuk menjalankan perintah nodemon insstead node.json.
#bash $ npm install -g nodemon--------------------------------------------------------------------#package.json {
"name": "node-dynamo-db",
"version": "0.0.0",
"private": true,
"scripts": {
"start": "nodemon ./bin/www"
},
"dependencies": {
"body-parser": "~1.18.2",
"cookie-parser": "~1.4.3",
"debug": "~2.6.9",
"express": "~4.15.5",
"jade": "~1.11.0",
"morgan": "~1.9.0",
"serve-favicon": "~2.4.5"
}
}
Menyiapkan DynamoDB
Pertama unduh file dari tautan di atas, unzip dan buka direktori. DynamoDB disediakan sebagai file .jar yang dapat dieksekusi. Untuk memulai database, Anda perlu menjalankan perintah berikut di dalam direktori tempat file .jar berada.
#bash $ java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDbInitializing DynamoDB Local with the following configuration:
Port: 8000
InMemory: false
DbPath: null
SharedDb: true
shouldDelayTransientStatuses: false
CorsParams: *
Anda sekarang memiliki instans DynamoDB lokal yang sedang berjalan. Masalahnya adalah, kecuali Anda memiliki memori fotografi, Anda mungkin tidak akan mengingat perintah di atas. Untuk mempercepatnya, buat perintah alias di .bashrc atau .zshrc Anda, tergantung apa yang Anda gunakan. milikku terlihat seperti ini.
#bash .zshrc or .bashrcalias ddb="cd path/to/dynamodb_local_latest && java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb"
Saya beri nama alias ddb. Alias ini akan masuk ke direktori dan menjalankan .jar. Itu mudah. Muat ulang jendela terminal Anda dan jalankan ddb dan DynamoDB akan dimulai.
#bash$ ddbInitializing DynamoDB Local with the following configuration:
Port: 8000
InMemory: false
DbPath: null
SharedDb: true
shouldDelayTransientStatuses: false
CorsParams: *
Sekarang Anda siap untuk mulai membuat tabel dan mengisinya dengan data. Untuk keperluan demo ini, kami akan membuat database yang berputar di sekitar mobil.
Sebelum melangkah lebih jauh, mari perbarui package.json kita untuk mengotomatiskan beberapa perintah yang cukup sering kita jalankan.
{
"name": "crafty-api",
"version": "0.0.0",
"private": true,
"scripts": {
"start": "nodemon app.js",
"create-db": "cd dynamodb && node createCarsTable.js && cd ..",
"delete-db": "cd dynamodb && node deleteCarsTable.js && cd ..",
"load-data": "cd dynamodb && node loadCarData.js && cd ..",
"read-data": "cd dynamodb && node readDataTest.js && cd .."
},
"dependencies": {
"aws-sdk": "^2.176.0",
"body-parser": "~1.18.2",
"cookie-parser": "~1.4.3",
"cors": "^2.8.4",
"debug": "~2.6.9",
"ejs": "^2.5.7",
"express": "~4.15.5",
"jade": "~1.11.0",
"morgan": "~1.9.0",
"newman": "^3.9.1",
"node-uuid": "^1.4.8",
"serve-favicon": "~2.4.5",
"uuid": "^3.2.1"
}
}
Ini adalah tampilan saya saat ini dan ini sangat mempercepat, jadi harap pertimbangkan untuk menambahkan milik Anda sendiri untuk mempercepat alur kerja Anda. tutorial js adalah cara yang bagus untuk mempelajari pemrograman Node.js.
Pertama, kita perlu membuat tabel dan memilih kunci partisi. Amazon memberikan beberapa saran yang sangat bagus di sini tentang kunci yang bagus. Kunci diperlukan karena Dynamo DB membagi data di beberapa unit penyimpanan dan menggunakan kunci untuk menyimpan dan membaca data. Oleh karena itu, kunci partisi harus bernilai unik. Contoh yang baik adalah user_ids dan devices_ids.
Saya memilih car_id di meja saya.
#JavaScript - createCarsTable.jsvar AWS = require("aws-sdk");AWS.config.update({
region: "eu-west-2",
endpoint: "http://localhost:8000"
});var dynamodb = new AWS.DynamoDB();var params = {
TableName : "Cars",
KeySchema: [
{ AttributeName: "id", KeyType: "HASH"}, //Partition key],
AttributeDefinitions: [
{ AttributeName: "id", AttributeType: "N" },],
ProvisionedThroughput: {
ReadCapacityUnits: 5,
WriteCapacityUnits: 5
}
};dynamodb.createTable(params, function(err, data) {
if (err) {
console.error("Unable to create table. Error JSON:", JSON.stringify(err, null, 2));
} else {
console.log("Created table. Table description JSON:", JSON.stringify(data, null, 2));
}
});
Sekarang jalankan perintah create-db dan lihat Dynamo DB berjalan di latar belakang di jendela terminal terpisah pada port 8000.
#bashyarn create-db
yarn run v1.3.2
$ cd dynamodb && node createCarsTable.js && cd ..
Created table. Table description JSON: {
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "id",
"AttributeType": "N"
}
],
"TableName": "Cars",
"KeySchema": [
{
"AttributeName": "id",
"KeyType": "HASH"
}
],
"TableStatus": "ACTIVE",
"CreationDateTime": "2018-02-01T16:08:25.308Z",
"ProvisionedThroughput": {
"LastIncreaseDateTime": "1970-01-01T00:00:00.000Z",
"LastDecreaseDateTime": "1970-01-01T00:00:00.000Z",
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:ddblocal:000000000000:table/Cars"
}
}
✨ Done in 0.47s.
Tabel sekarang sudah diatur dan siap untuk diunggulkan dengan data.
Contoh ini menggunakan metode Dynamo DB PutItem untuk mengisi basis data dengan data.
#JSON - carData.json [
{ "id": 1,
"type" : "Automatic",
"name" : "Toyota Yaris",
"manufacturer" : "Toyota",
"fuel_type" : "Petrol",
"description" : "A smooth ride"
},
{ "id": 2,
"type" : "Manual",
"name" : "Volkswagen Golf",
"manufacturer" : "Volkswagen",
"fuel_type" : "Petrol",
"description" : "Good Value"
}
]------------------------------------------------------------------#JavaScript - loadCarData.jsvar AWS = require("aws-sdk");
var fs = require('fs');AWS.config.update({
region: "eu-west-2",
endpoint: "http://localhost:8000"
});var docClient = new AWS.DynamoDB.DocumentClient();console.log("Importing Cars into DynamoDB. Please wait.");var cars = JSON.parse(fs.readFileSync('carData.json', 'utf8'));cars.forEach(function(car) {
console.log(car)var params = {
TableName: "Cars",
Item: {
"id": car.id,
"type": car.type,
"name": car.name,
"manufacturer": car.manufacturer,
"fuel_type": car.fuel_type,
"description": car.description
}
};docClient.put(params, function(err, data) {
if (err) {
console.error("Unable to add Car", car.name, ". Error JSON:", JSON.stringify(err, null, 2));
} else {
console.log("PutItem succeeded:", car.name);
}
});
});
Menjalankan perintah load-data akan memunculkan dua item di file carData.json dan mencatat namanya ke konsol sebagai berikut:
#bash yarn load-data
yarn run v1.3.2
$ cd dynamodb && node loadCarData.js && cd ..
Importing Cars into DynamoDB. Please wait.
{ id: 1,
type: 'Automatic',
name: 'Toyota Yaris',
manufacturer: 'Toyota',
fuel_type: 'Petrol',
description: 'A smooth ride' }
{ id: 2,
type: 'Manual',
name: 'Volkswagen Golf',
manufacturer: 'Volkswagen',
fuel_type: 'Petrol',
description: 'Good Value' }
PutItem succeeded: Toyota Yaris
PutItem succeeded: Volkswagen Golf
✨ Done in 0.46s.
Datanya ada, tetapi bagaimana Anda tahu Mari kita jalankan tes cepat menggunakan metode .get DocumentClient Dynamo DB. DocumentClient hanyalah kelas yang menyederhanakan pekerjaan dengan item DynamoDB.
#JavaScript - readDataTest.js var AWS = require("aws-sdk");AWS.config.update({
region: "eu-west-2",
endpoint: "http://localhost:8000"
});var docClient = new AWS.DynamoDB.DocumentClient()var table = "Cars";var id = 1;var params = {
TableName: table,
Key:{
"id": id
}
};docClient.get(params, function(err, data) {
if (err) {
console.error("Unable to read item. Error JSON:", JSON.stringify(err, null, 2));
} else {
console.log("GetItem succeeded:", JSON.stringify(data, null, 2));
}
});
Jika Anda mengingat file JSON, Anda akan mengharapkan Toyota Yaris kembali ke konsol…
#bash
$ yarn read-data
yarn run v1.3.2
$ cd dynamodb && node readDataTest.js && cd ..
GetItem succeeded: {
"Item": {
"name": "Toyota Yaris",
"description": "A smooth ride",
"id": 1,
"type": "Automatic",
"fuel_type": "Petrol",
"manufacturer": "Toyota"
}
}
✨ Done in 0.56s.
Bam! Sekarang setelah DynamoDB disiapkan dan diunggulkan dengan data, kita perlu menggabungkan semua bagiannya.
satukan semuanya
Pada titik ini, backend Node sama sekali tidak berkomunikasi dengan Dynamo DB. Kami akan memasukkan dan memodifikasi beberapa metode yang digunakan di atas untuk membuat rute yang mengembalikan semua mobil.
Untuk melakukannya, gunakan metode pemindaian DocClient DynamoDB.
#Javascript app.jsvar express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var AWS = require("aws-sdk");var app = express();app.listen(3000, () => console.log('Cars API listening on port 3000!'))AWS.config.update({
region: "eu-west-2",
endpoint: "http://localhost:8000"
});var docClient = new AWS.DynamoDB.DocumentClient();app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.set('view engine', 'jade');app.get('/', function (req, res) {
res.send({ title: "Cars API Entry Point" })
})app.get('/cars', function (req, res) {var params = {
TableName: "Cars",
ProjectionExpression: "#id, #name, #type, #manufacturer, #fuel_type, #description",
ExpressionAttributeNames: {
"#id": "id",
"#name": "name",
"#type": "type",
"#manufacturer": "manufacturer",
"#fuel_type": "fuel_type",
"#description": "description"
}
};console.log("Scanning Cars table.");
docClient.scan(params, onScan);function onScan(err, data) {
if (err) {
console.error("Unable to scan the table. Error JSON:", JSON.stringify(err, null, 2));
} else {
res.send(data)
// print all the Cars
console.log("Scan succeeded.");
data.Items.forEach(function(car) {
console.log(car.id, car.type, car.name)
});if (typeof data.LastEvaluatedKey != "undefined") {
console.log("Scanning for more...");
params.ExclusiveStartKey = data.LastEvaluatedKey;
docClient.scan(params, onScan);
}
}
}
})
Seperti inilah tampilan file app.js. Saya tahu saya dapat memfaktorkan ulang ini dan memindahkan beberapa kode ke folder rute, tetapi saya akan menyerahkannya kepada Anda untuk menyimpan artikel ini seluk beluk mungkin.
Buat rute baru bernama /cars dan buat variabel params seperti yang ditunjukkan file. Variabel ini berisi nama tabel dan apa yang dikembalikan dari pemindaian. Selanjutnya, buat fungsi bernama onScan yang mengirim data ke klien dan mencatat hasilnya ke konsol. Ini juga mencakup beberapa tangkapan kesalahan jika ada masalah dengan permintaan tersebut.
Sekarang buka http://localhost:3000/cars dan Anda akan melihat sesuatu seperti ini:
#JSON - response from http://localhost:3000/cars{"Items":[{"name":"Volkswagen Golf","description":"Good Value","id":2,"fuel_type":"Petrol","type":"Manual","manufacturer":"Volkswagen"},{"name":"Toyota Yaris","description":"A smooth ride","id":1,"fuel_type":"Petrol","type":"Automatic","manufacturer":"Toyota"}],"Count":2,"ScannedCount":2}
bagus sekali! Anda sekarang memiliki blok penyusun API RESTful Node.js menggunakan AWS DynamoDB. Selain itu, Anda dapat mempelajari ExpressJS untuk mengembangkan aplikasi web yang lebih cepat dan cerdas di sisi server.
Mari jalankan rute lain yang meminta DynamoDB mengembalikan mobil dengan ID.
Sebut saja root /cars/:id. Lewati ID melalui URL permintaan. Kemudian gunakan ID untuk menanyakan tabel dan mengembalikan mobil yang benar. Iris string untuk mendapatkan nilai id dan kembalikan hanya nilai numerik.
Tapi ingat, saat kami membuat tabel, kami menentukan bahwa id bertipe numerik. Jadi, jika Anda mencoba meneruskan nilai apa adanya ke DynamoDB, itu akan menghasilkan kesalahan. Pertama, kita perlu mengonversi nilai id dari string menjadi integer menggunakan parseInt().
#JavaScript - app.js[...]app.get('/cars/:id', function (req, res) {var carID = parseInt(req.url.slice(6));
console.log(req.url)
console.log(carID)var params = {
TableName : "Cars",
KeyConditionExpression: "#id = :id",
ExpressionAttributeNames:{
"#id": "id"
},
ExpressionAttributeValues: {
":id": carID
}
};docClient.query(params, function(err, data) {
if (err) {
console.error("Unable to query. Error:", JSON.stringify(err, null, 2));
} else {
console.log("Query succeeded.");
res.send(data.Items)
data.Items.forEach(function(car) {
console.log(car.id, car.name, car.type);
});
}
});});
Simpan nilai carID yang dikonversi dalam variabel dan gunakan ini di objek params. Kemudian gunakan metode kueri untuk mengumpulkan data dan mengembalikannya ke klien. Jika semuanya sudah diatur dengan benar, Anda dapat membuka http://localhost:3000/cars/1 dan melihat Yaris dikembalikan sebagai JSON. Memeriksa terminal menunjukkan ID, nama, dan jenis mobil yang diminta.
#JSON - http://localhost:3000/cars/1[{"name":"Toyota Yaris","description":"A smooth ride","id":1,"type":"Automatic","fuel_type":"Petrol","manufacturer":"Toyota"}]#bash$ yarn start
[nodemon] starting `node app.js`
Cars API listening on port 3000!
/cars/1
1
Query succeeded.
1 'Toyota Yaris' 'Automatic'
GET /cars/1 200 47.279 ms - 126
Dari sini sepertinya Anda dapat menambahkan rute tambahan untuk mencari berdasarkan nama mobil, model mobil, dan mengimplementasikan POSTing ke DB. Tip: Ini mirip dengan file loadCarData.js dengan fungsi PutItem DynamoDB.
Lain kali, saya berencana menerapkan aplikasi sampel ke AWS Elastic Beanstalk dengan AWS DynamoDB, mengimplementasikan pipeline build dengan CircleCI, dan menguji menggunakan Postman.
Seperti biasa, terima kasih telah membaca..