Inilah Alat Load Testing Untuk Node.js Developer
Artileri
Artillery adalah alat pengujian beban dan pembandingan performa sumber terbuka untuk API, service mikro, dan website. Ini memungkinkannya Anda tentukan scenario pengujian beban HTTP dan menjalankannya pada mekanisme sasaran Anda untuk tentukan karakter performanya dalam beragam keadaan. Artillery menyediakan fitur-fitur seperti pengertian skenario yang fleksibel, laporan real-time, dan pemetaan automatis roadway, menjadikan opsi terkenal untuk pengetesan dan optimalisasi performa.
Berikut contoh bagaimana Anda bisa memakai Artileri untuk berisi pengetesan server Node.js:
- Pasang Artileri:
npm install -g artillery2. Buat file bernama test.yml dengan konten berikut:
config:
target: "http://localhost:3000"
phases:
- duration: 60
arrivalRate: 5
scenarios:
- flow:
- get:
url: "/"Skenario ini menentukan alur tunggal yang mengirimkan permintaan GET ke URL akar sistem target, dengan tingkat kedatangan konstan 5 permintaan per detik selama 60 detik.
3. Mulai pengujian:
artillery run test.yml4. Lihat hasilnya:
Artillery akan menghasilkan laporan dengan metrik performa pengujian, termasuk permintaan per detik, waktu respons, dan tingkat kesalahan.
Lebih Banyak Contoh:
config:
target: "http://localhost:3000"
phases:
- duration: 30
arrivalRate: 5
- duration: 30
arrivalRate: 10
scenarios:
- flow:
- post:
url: "/api/login"
json:
username: "testuser"
password: "testpassword"
capture:
json: "$.token"
as: "token"
- get:
url: "/api/user"
headers:
Authorization: "Bearer {{token}}"Dalam contoh ini, Artileri menjalankan skenario pengujian yang mensimulasikan keinginan masuk di titik akhir /api/login, tangkap tanggapan JSON dan mengekstrak token, lalu memakai token untuk membikin keinginan di titik akhir /api/pengguna dengan Judul otorisasi. Test akan jalan sepanjang 60 detik pada dua tingkat kehadiran yang lain, 5 keinginan per detik untuk 30 detik pertama, dan 10 keinginan per detik untuk 30 detik selanjutnya.
k6
k6 adalah alat pengujian beban sumber terbuka yang direncanakan untuk menolong pengembang dan insinyur performa mengetes performa dan skalabilitas program situs dan API mereka. k6 dicatat dalam Go dan memakai JavaScript sebagai bahasa skripnya, yang membuat gampang dipakai dan memberi tingkat fleksibilitas dan penyesuaian yang cukup tinggi.
Dengan k6, Anda bisa tentukan skenario pengetesan yang sulit dan menjalankannya pada mekanisme sasaran Anda untuk menghitung beragam metrik performa waktu seperti tanggapan, keinginan per detik, dan tingkat kesalahan. k6 sediakan laporan waktu nyata dan kekuatan visualisasi, membuat gampang untuk menganalisa hasil pengetesan dan mengenali kendala performa.
k6 adalah opsi terkenal untuk pengetesan performa karena keringanan penggunaan, keserbagunaan, dan kekuatannya untuk berintegrasi dengan alat dan service lain seperti pipa CI/CD, mekanisme pengawasan, dan basis pengetesan beban berbasiskan cloud.
Berikut contoh bagaimana Anda bisa memakai k6 untuk berisi pengetesan server Node.js:
- Instal k6:
npm install -g k62. Buat file skrip:
Buat file bernama test.js dengan konten berikut:
import http from "k6/http";
export default function() {
http.get("http://localhost:3000/");
};Skrip ini mendefinisikan permintaan GET HTTP tunggal ke URL root dari sistem target.
3. Mulai pengujian:
k6 run test.js4. Lihat hasilnya:
k6 akan hasilkan laporan dengan metrik performa pengetesan, terhitung keinginan per detik, waktu tanggapan, dan tingkat kesalahan. Laporan bisa disamakan selanjutnya dan divisualisasikan dengan kontribusi kekuatan laporan dan visualisasi bawaan k6.
Lebih Banyak Contoh:
import http from "k6/http";
import { check, sleep } from "k6";
export let options = {
stages: [
{ duration: "30s", target: 5 },
{ duration: "30s", target: 10 },
],
};
export default function() {
let res = http.post("http://localhost:3000/api/login", JSON.stringify({
username: "testuser",
password: "testpassword",
}), {
headers: {
"Content-Type": "application/json",
},
});
check(res, {
"status is 200": (r) => r.status === 200,
"login successful": (r) => JSON.parse(r.body).success === true,
});
let token = JSON.parse(res.body).token;
res = http.get("http://localhost:3000/api/user", {
headers: {
Authorization: `Bearer ${token}`,
},
});
check(res, {
"status is 200": (r) => r.status === 200,
});
sleep(1);Dalam contoh ini, k6 menjalankan skenario pengujian yang mensimulasikan keinginan login di titik akhir /api/login, tangkap tanggapan JSON dan mengekstrak token, lalu memakai token untuk membikin keinginan di titik akhir /api/pengguna dengan Judul otorisasi. Test akan jalan sepanjang 60 detik pada dua tingkat kehadiran sasaran yang lain, 5 keinginan per detik untuk 30 detik pertama, dan 10 keinginan per detik untuk 30 detik selanjutnya.
Autocannon
Autocannon adalah pustaka Node.js untuk pengetesan performa API HTTP/1.1 dan HTTP/2. Ini memungkinkannya Anda dengan mudah dan cepat membuat dan jalankan tolak ukur pada API Anda untuk tentukan karakter performanya, terhitung keinginan per detik, latency, dan metrik penting yang lain. Autocannon bisa dipakai untuk menguji performa satu titik akhir API, atau untuk mengetes beberapa titik akhir secara bertepatan untuk memperoleh penampilan yang lebih mendalam dari keseluruhnya performa API Anda.
Berikut contoh simpel langkah memakai Autocannon di Node.js untuk mengetes performa titik akhir API:
- Instal Autocannon:
npm install autocannon2. Buat file skrip:
Buat file bernama test.js dengan konten berikut:
const autocannon = require('autocannon');
const instance = autocannon({
url: 'http://localhost:3000/api/endpoint',
connections: 10,
pipelining: 1,
duration: 10
});
instance.on('done', () => {
console.log('Test completed.');
console.log('Requests per second: ', instance.stats.requests);
console.log('Latency average: ', instance.stats.latency.avg);
console.log('Latency max: ', instance.stats.latency.max);
});
instance.run();Dalam perumpamaan ini, kami memakai Autocannon untuk menguji performa titik akhir API di http://localhost:3000/api/endpoint. Kami memakai 10 jaringan, salurkan 1 keinginan sekalian, dan jalankan pengujian sepanjang 10 detik. Sesudah pengetesan usai, kami menulis hasilnya ke konsol, terhitung keinginan per detik, latensi rata-rata, dan latensi maksimal.
Lebih Banyak Contoh:
Apache Bench
Apache Bench (ab) adalah alat baris perintah simpel yang dipakai untuk mengetes performa server HTTP. Ini memungkinkannya Anda mengirimi beberapa keinginan bersamaan ke URL sasaran dan menghitung waktu tanggapan dan metrik performa yang lain, seperti jumlah permintaan per detik dan keseluruhan saat yang diperlukan untuk menuntaskan semua keinginan. Apache Bench umumnya dipakai untuk memperbandingkan server situs, mengetes performa API, dan menilai keseluruhnya kemampuan dan skalabilitas server. Ini adalah sisi dari proyek Apache HTTP Server, dan ada sebagai alat standard pada sebagian besar mekanisme serupa Unix.
Berikut contoh bagaimana Anda bisa memakai Apache Bench untuk mengetes server Node.js simpel:
- Pertama, yakinkan Apache Bench terinstal di mekanisme Anda. Pada mayoritas mekanisme serupa Unix, ini telah diinstall sebagai alat standard. Bila belum diinstall, Anda bisa menginstal memakai pengurus paket, seperti apt-get di Ubuntu:
$ sudo apt-get install apache2-utils2. Mulai server Node.js sederhana di localhost, port 3000:
$ node index.js3. Di jendela terminal terpisah, jalankan Apache Bench pada server Node.js:
$ ab -n 1000 -c 100 http://localhost:3000/Dalam contoh ini, ab mengirimkan 1000 permintaan ke http://localhost:3000/, memakai 100 koneksi bersamaan. Output dari perintah akan memperlihatkan berbagai metrik performa, seperti jumlah keinginan per detik, waktu yang diperlukan untuk menuntaskan semua keinginan, latensi rata-rata dan median, dan jumlah keinginan yang tidak berhasil.