Perbandingan Performa Golang Gin & Node.js Express

No	Tipe Permintaan	Endpoint	Deskripsi
1	GET	/{short-link}	Merupakan fitur utama yang digunakan untuk mendapatkan link asli berdasarkan input parameter short link
2	POST	/auth/login	Fitur login untuk user mendapatkan token autentikasi
3	GET	/users	Mendapatkan data banyak users
4	POST	/users	Membuat data user baru
5	PATCH	/users/self	Mengupdate data pribadi milik user
6	GET	/users/self	Mendapatkan data pribadi user milik pribadi
7	GET	/users/{username}	Mendapatkan data pribadi user lain dengan berdasarkan username user tersebut
8	PATCH	/users/status	Mengubah status keaktifan user lain
9	PATCH	/users/password	Mengubah password pribadi user
10	DELETE	/users/{id}	Menghapus data user lain
11	GET	/links	Mendapatkan data banyak short link
12	POST	/links	Membuat data short link baru
13	PATCH	/links	Mengedit data short link pribadi
14	DELETE	/links	Menghapus data short link
15	GET	/links/self	Mendapatkan data short link yang pernah dibuat
16	GET	/links/{id}	Mendapatkan satu data short link berdasarkan id short link

Pengujian Performa API

Pengujian menggunakan tools K6, sebuah tools Open Source yang digunakan untuk pengujian performa, ditulis dalam bahasa Golang serta penulisan skrip pengujian ditulis dalam Javascript. K6 Docs.

Skenario Pengujian

Setiap skenario pengujian yang akan dilakukan akan menggunakan skenario yang sama antara Golang Gin dan Node.js Express dengan database Postgresql dan MongoDB. Skenario pengujian yang akan dilakukan akan terdiri dari 4 jenis pengujian yang akan dilakukan.

Smoke Testing
Breakpoint Testing
Load Testing
Spike Testing

Smoke Testing

Pengujian sebelum melakukan pengujian lainnya untuk memastikan skenario pengujian berjalan sesuai harapan

Breakpoint Testing

Pengujian bertujuan mencari ambang batas rps (request per second) sistem yang akan digunakan sebagai dasar pengujian load dan spike testing

Load Testing

Pengujian untuk melihat bagaimana sistem menahan normal dengan juga melihat bagaimana utilisasi cpu dan memory yang digunakan sistem

Spike Testing

Pengujian untuk melihat bagaimana sistem menahan beban yang meningkat dengan cepat sampai di atas rataan beban normal sistem dan kemudian beban turun dengan cepat. Melihat hasil utilisasi cpu dan memori sistem terhadap skenario yang diberikan

Jenis Pengujian

Setiap pengujian akan memiliki karakteristik serta waktu lama pengujian yang berbeda - beda sesuai dengan tujuan dari masing - masing pengujian.

No	Nama Pengujian	Waktu	Data
1	Smoke	5 detik	5 virtual users
2	Breakpoint	60 menit (maksimal)	Target maksimal 10000 rps (Iteration per second) Angka batas sistem gagal ketika total permintaan gagal mencapai 10% dari semua permintaan yang dilakukan
3	Load	40 menit 5 menit menaikkan beban ke target 30 menit menahan beban 5 menit menurunkan beban kembali ke 0	Target beban yang akan ditahan didapatkan berdasarkan hasil pengujian breakpoint dengan menggunakan n nilai rps yang didapatkan
4	Spike	7 menit 1 menit menaikkan beban ke target 5 menit menahan beban 1 menit menurunkan beban kembali ke 0	Target beban yang akan ditahan didapatkan berdasarkan hasil pengujian breakpoint dengan menggunakan n nilai rps yang didapatkan dengan menaikkan nilai beban sebanyak 100% untuk gambaran lonjakan beban yang ada

Skenario Pengujian

No	Endpoint diuji	Deskripsi
1	POST /login	Melakukan pengujian untuk login dan mendapatkan token autentikasi
2	GET /{short-link}	Melakukan pengujian untuk fitur utama short link dan mendapatkan data link asli
3	GET /links	Melakukan pengujian mendapatkan banyak data short link sekaligus
4	POST /links	Melakukan pengujian membuat data short link baru
5	PATCH /links	Melakukan pengujian mengubah data short link yang sudah ada
6	GET /links/self	Melakukan pengujian mendapatkan banyak data short link milik pribadi yang telah dibuat
7	DELETE /links	Melakukan pengujian menghapus data short link
8	E2E (End to End) Mencangkup: - POST /login - GET /links/self - POST /links - GET /{short-link} - PATCH /links - GET /{short-link} - DELETE /links	Melakukan pengujian e2e (end to end) untuk menggambarkan alur yang umum digunakan oleh pengguna
9	E2E (End to End) Mencangkup: - GET /links/self - POST /links - GET /{short-link} - PATCH /links - GET /{short-link} - DELETE /links	Melakukan pengujian e2e (end to end) untuk menggambarkan alur yang umum digunakan oleh pengguna

Detail Skenario

Total skenario pengujian yang akan diuji akan memiliki total 9 skenario dengan rincian 7 merupakan pengujian endpoint tunggal yang sudah mencangkup untuk semua jenis request dan 2 merupakan pengujian End to End (E2E) yang menggambarkan alur penggunaan endpoint dari mulai login sampai menghapus data short url yang dibuat.
Kedua pengujian E2E memiliki alur yang sama, perbedaan terdapat pada salah satu E2E tidak menggunakan proses login. Hal tersebut dikarenakan proses login terbilang cukup berat karena ada hashing maka dengan menghilangkan proses login akan dapat menjadi perbandingan dan bahan analisis lebih lanjut dengan skema yang sama dan menghilangkan satu proses yang berat bagaimana hasil dari pengujian yang dihasilkan dari semua skenario pengujian API yang akan dilakukan

Total Waktu Pengujian

Tanpa menghitung proses Breakpoint Testing yang total waktunya akan bersifat tentatif, maka menghitung waktu Load dan Spike testing yang kedua pengujian tersebut memiliki total waktu pengujian 47 menit dikalikan dengan 9 skenario pengujian dan dikalikan kembali dengan 4 total bahan uji maka total waktu pengujian paling sebentar adalah 1.692 menit atau 28 jam

Penulisan Skrip Pengujian

Skrip pengujian yang dijalankan pada K6 akan ditulis dengan kode dasar javascript. Secara umum skrip yang ditulis akan ada dua jenis struktur umum yaitu untuk pengujian satu endpoint dan untuk E2E dimana pada skrip E2E akan memanggil banyak endpoint sekaligus dalam satu skrip. Terdapat contoh untuk skrip pengujian yang akan dilakukan untuk pengujian satu endpoint dan E2E. Serta juga disediakan juga terkait repositry Github yang berisi skrip keseluruhan skrip pengujian.

Skrip Pengujian


import http from 'k6/http';
import { check } from 'k6';
import { textSummary } from "https://jslib.k6.io/k6-summary/0.0.1/index.js";
import { randomString } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';

export function handleSummary(data) {
    console.log('Preparing the end-of-test summary...');
    return {
        "stdout": textSummary(data, { indent: ' ', enableColors: true }),
    };
}

let SCENARIO, SCENARIO_TYPE, DB_TYPE, BASE_URL 
let JWT, USER_TYPE, LONG_LINK, CUSTOM_LINK, SERVICE 


SCENARIO_TYPE = __ENV.SCENARIO
DB_TYPE = __ENV.DB_TYPE

BASE_URL = __ENV.SERVICE
if(BASE_URL === 'golang') BASE_URL = __ENV.ENDPOINT_GOLANG
else BASE_URL = __ENV.ENDPOINT_NODE

SERVICE =  __ENV.SERVICE

USER_TYPE = __ENV.USER_TYPE
if(USER_TYPE === 'admin') {
    if(DB_TYPE === 'mongo') JWT = __ENV.JWT_ADMIN_NOSQL
    else JWT = __ENV.JWT_ADMIN_SQL
} else {
    if(DB_TYPE === 'mongo') JWT = __ENV.JWT_USER_NOSQL
    else JWT = __ENV.JWT_USER_SQL
}

LONG_LINK = __ENV.LONG_LINK
CUSTOM_LINK = __ENV.CUSTOM_LINK === 'true' ? true : false 

let SCENARIOS = {
    breakpoint: {
        executor: 'ramping-arrival-rate',
        startRate: 0,
        timeUnit: '1s',
        preAllocatedVUs: 1000, 
        stages: [
            { duration: '60m', target: 10000 },
        ],
    },
    load: {
        executor: 'ramping-arrival-rate',
        startRate: 0,
        timeUnit: '1s',
        preAllocatedVUs: 1000, 
        maxVUs: 100000, 
        stages: [
            { duration: '5m', target: 31 },
            { duration: '30m', target: 31 },
            { duration: '5m', target: 0 },
        ],
    },
    spike: {
        executor: 'ramping-arrival-rate',
        startRate: 0,
        timeUnit: '1s',
        preAllocatedVUs: 2000,
        maxVUs: 8000,
        stages: [
            { duration: '1m', target: 75 }, 
            { duration: '5m', target: 75 }, 
            { duration: '1m', target: 0 },  
        ]
    },
    smoke: {
        executor: 'constant-vus',
        vus: 5,
        duration: '5s',
    }
}


let THRESHOLD = {
    http_req_failed: [
        {
        threshold:'rate<0.05',
        abortOnFail: true,
        delayAbortEval: "10s",
    }]
}

SCENARIO = {
    scenarios: {
        [SCENARIO_TYPE]: SCENARIOS[SCENARIO_TYPE]
    }
}

if(SCENARIO_TYPE === 'breakpoint') SCENARIO.thresholds = THRESHOLD

export function setup() {
    console.log(`Start Create New Short Link Testing with ${SCENARIO_TYPE} test, using service: ${__ENV.SERVICE} base url: ${BASE_URL} db type: ${DB_TYPE} with type user: ${USER_TYPE}`)   
}

export const options = SCENARIO

export default function () {
    let endpoint = BASE_URL

    endpoint = `${endpoint}/links?` 

    if(DB_TYPE === 'mongo') endpoint = endpoint + 'db=mongo'

    const options = {
        headers: {
            Authorization: `Bearer ${JWT}`
        }
    }

    let short_link = __ENV.SHORT_LINK
    if(CUSTOM_LINK) short_link = randomString(5, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

    let body = {
        long_url: LONG_LINK,
        short_url: short_link,
        custom_link: CUSTOM_LINK
    }

    if(SERVICE === 'golang') body = JSON.stringify(body)

    const res = http.post(
        endpoint,
        body,
        options
    )
    
    check(res, {
        'is status 200': (r) => r.status == 200,
    })
}

                                        
import http from 'k6/http';
import { check, group } from 'k6';
import { textSummary } from "https://jslib.k6.io/k6-summary/0.0.1/index.js";
import { randomString } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';

export function handleSummary(data) {
    console.log('Preparing the end-of-test summary...');
    return {
        "stdout": textSummary(data, { indent: ' ', enableColors: true }),
    };
}

let SCENARIO, SCENARIO_TYPE, DB_TYPE, BASE_URL 
let USER_TYPE, LONG_LINK, CUSTOM_LINK, USERNAME, PASSWORD 

SCENARIO_TYPE = __ENV.SCENARIO
DB_TYPE = __ENV.DB_TYPE

BASE_URL = __ENV.SERVICE
if(BASE_URL === 'golang') BASE_URL = __ENV.ENDPOINT_GOLANG
else BASE_URL = __ENV.ENDPOINT_NODE

PASSWORD = __ENV.PASSWORD
USER_TYPE = __ENV.USER_TYPE
if(USER_TYPE === 'admin') USERNAME = __ENV.USERNAME_ADMIN
else USERNAME = __ENV.USERNAME_USER

LONG_LINK = __ENV.LONG_LINK
CUSTOM_LINK = __ENV.CUSTOM_LINK === 'true' ? true : false

let SCENARIOS = {
    breakpoint: {
        executor: 'ramping-arrival-rate',
        startRate: 0,
        timeUnit: '1s',
        preAllocatedVUs: 1000, 
        stages: [
            { duration: '60m', target: 10000 },
        ],
    },
    load: {
        executor: 'ramping-arrival-rate',
        startRate: 0,
        timeUnit: '1s',
        preAllocatedVUs: 1000, 
        maxVUs: 100000, 
        stages: [
            { duration: '5m', target: 31 },
            { duration: '30m', target: 31 },
            { duration: '5m', target: 0 },
        ],
    },
    spike: {
        executor: 'ramping-arrival-rate',
        startRate: 0,
        timeUnit: '1s',
        preAllocatedVUs: 2000,
        maxVUs: 8000,
        stages: [
            { duration: '1m', target: 75 }, 
            { duration: '5m', target: 75 }, 
            { duration: '1m', target: 0 },  
        ]
    },
    smoke: {
        executor: 'constant-vus',
        vus: 5,
        duration: '5s',
    }
}


let THRESHOLD = {
    http_req_failed: [
        {
        threshold:'rate<0.05',
        abortOnFail: true,
        delayAbortEval: "10s",
    }]
}

SCENARIO = {
    scenarios: {
        [SCENARIO_TYPE]: SCENARIOS[SCENARIO_TYPE]
    }
}

if(SCENARIO_TYPE === 'breakpoint') SCENARIO.thresholds = THRESHOLD

export function setup() {
    console.log(`Start E2E Testing with ${SCENARIO_TYPE} test, using service: ${__ENV.SERVICE} base url: ${BASE_URL} db type: ${DB_TYPE} with type user: ${USER_TYPE}`)   

    const endpoints = {
        endpoint_login: `${BASE_URL}/auth/login`,
        endpoint_get_link_self: `${BASE_URL}/links/self`,
        endpoint_links: `${BASE_URL}/links`
    };
    
    const addDBType = (url) => DB_TYPE === 'mongo' ? `${url}?db=mongo` : url
    
    const updatedEndpoints = Object.fromEntries(
        Object.entries(endpoints).map(([key, value]) => [key, addDBType(value)])
    );
    
    const { endpoint_login, endpoint_get_link_self, endpoint_links } = updatedEndpoints


    return {
        endpoint_login, 
        endpoint_get_link_self, 
        endpoint_links
    }
}

export const options = SCENARIO

export default function (data) {
    let { endpoint_login, endpoint_get_link_self, endpoint_links } = data
    let id_url_created, headers, endpoint_link_main

    const SERVICE = __ENV.SERVICE

    const create_main_get_link = (short_link) => {
        let url = BASE_URL + '/' + short_link
        if(DB_TYPE === 'mongo') url = url + '?db=mongo'
        return url
    }

    const createHeader = (token) => {
        return {
            headers: {
                Authorization: `Bearer ${token}`
            }
        }
    }

    group('1. Login', () => {
        let body = {
            username: USERNAME,
            password: PASSWORD
        }

        if (SERVICE === 'golang') body = JSON.stringify(body)

        const res = http.post(
            endpoint_login,
            body
        )

        const status = check(res, {
            'is status 200': (r) => r.status == 200,
        })

        if(!status) {
            console.log('Failed to login')
            return
        } else headers = createHeader(res.json().data.access_token)
    })

    group('2. Get Links Self Data', () => {
        const res = http.get(
            endpoint_get_link_self,
            headers
        )

        const status = check(res, {
            'is status 200': (r) => r.status == 200,
        })

        if(!status) {
            console.log('Failed to get link self data')
            return
        }
    })

    group('3. Create Link', () => {
        let short_link = __ENV.SHORT_LINK
        if(CUSTOM_LINK) short_link = randomString(5, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

        let body = {
            long_url: LONG_LINK,
            short_url: short_link,
            custom_link: CUSTOM_LINK
        }

        if (SERVICE === 'golang') body = JSON.stringify(body)

        const res = http.post(
            endpoint_links,
            body,
            headers
        )
        
        const status = check(res, {
            'is status 200': (r) => r.status == 200,
        })

        if(!status) {
            console.log('Failed to create link')
            return
        } else {
            id_url_created = res.json().data.inserted_id
            endpoint_link_main = create_main_get_link(res.json().data.short_url)
        }
    })

    group('4. Check Created Link 1', () => {
        const res = http.get(
            endpoint_link_main
        )

        const status = check(res, {
            'is status 200': (r) => r.status == 200,
        })

        if(!status) {
            console.log('Failed to Check Link 1')
            return
        }
    })

    group('5. Edit Link Data', () => {
        let short_link = __ENV.SHORT_LINK
        if(CUSTOM_LINK) short_link = randomString(5, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

        let body = {
            url_id: id_url_created,
            long_url: LONG_LINK,
            short_url: short_link,
            custom_link: CUSTOM_LINK
        }

        if (SERVICE === 'golang') body = JSON.stringify(body)

        const res = http.patch(
            endpoint_links,
            body,
            headers
        )
        
        const status = check(res, {
            'is status 200': (r) => r.status == 200,
        })

        if(!status) {
            console.log('Failed to ')
            return
        } else endpoint_link_main = create_main_get_link(res.json().data.short_url)
    })

    group('6. Check Created Link 2', () => {
        const res = http.get(
            endpoint_link_main
        )

        const status = check(res, {
            'is status 200': (r) => r.status == 200,
        })

        if(!status) {
            console.log('Failed to Check Link 2')
            return
        }
    })

    group('7. Deleted Link', () => {
        let body = {
            url_id: id_url_created,
        }

        if (SERVICE === 'golang') body = JSON.stringify(body)

        const res = http.del(
            endpoint_links,
            body,
            headers
        )
        
        const status = check(res, {
            'is status 200': (r) => r.status == 200,
        })

        if(!status) {
            console.log('Failed to delete link')
            return
        }
    })
}

Perfomance Testing Repository

Pengujian

Pengujian dijalankan sesuai skenario yang sudah ditulis pada setiap jenis pengujian yang akan dilakukan. Setiap skenario akan secara urut melewati jenis pengujian dari Smoke Testing, Breakpoint Testing, Load Testing, dan Spike Testing. Pengujian akan menghasilkan data yang akan digunakan untuk analisis hasil pengujian seperti iterasi per detik yang didapatkan dari Breakpoint testing, kemudian juga hasil pengujian Load dan Spike testing yang akan digunakan untuk melihat bagaimana sistem menahan beban yang diberikan yang hasil tersebut.
Pengujian yang dilakukan pada Command Line juga selain hasilkan output CLI juga menghasilkan satu file HTML berisi hasil pengujian yang dilakukan yang akan digunakan sebagai bahan analisis hasil pengujian yang dilakukan dan untuk utilisasi cpu dan memory yang digunakan sistem didapatkan dari metrik yang disediakan oleh Cloud Run.

Hasil Pengujian

Analisis

Melakukan analisis hasil pengujian yang telah dilakukan pada semua skenario pengujian. Mencari tau terkait bagaimana performa yang didapatkan oleh masih - masing skenario sistem yang telah diuji.

Nilai Pengujian Breakpoint, Load, dan Spike

Dalam tabel yang tersedia merupakan besaran iterasi per detik maksimal yang dibebankan pada Load & Spike Testing masing - masing skenario sistem yang didapatkan berdasarkan Breakpoint Testing yang dilakukan. Semakin tinggi nilai iterasi per detik yang didapatkan maka semakin baik performa sistem yang dihasilkan. Dimana beban pada load testing akan menggunakan nilai berdasar pada breakpoint testing dan juga beban pada spike testing akan berdasar pada dua kali beban pada load testing.

Hasil Breakpoint testing akan menjadi dasar untuk digunakan pada Load & Spike testing dengan pembulatan nilai minimum adalah 1 dan pada Spike Testing nilai digunakan adalah dua kali dari nilai pada Load Testing

Skenario	Servis / Basis Data	Breakpoint
POST /login	Node.js / PostgreSQL	6
	Node.js / MongoDB	6
	Golang / PostgreSQL	3
	Golang / MongoDB	3
GET /links	Node.js / PostgreSQL	34
	Node.js / MongoDB	7
	Golang / PostgreSQL	32
	Golang / MongoDB	26
GET /{short-link}	Node.js / PostgreSQL	68
	Node.js / MongoDB	47
	Golang / PostgreSQL	81
	Golang / MongoDB	69
POST /links	Node.js / PostgreSQL	61
	Node.js / MongoDB	29
	Golang / PostgreSQL	72
	Golang / MongoDB	29
PATCH /links	Node.js / PostgreSQL	15
	Node.js / MongoDB	5
	Golang / PostgreSQL	15
	Golang / MongoDB	7
GET /links/self	Node.js / PostgreSQL	18
	Node.js / MongoDB	13
	Golang / PostgreSQL	32
	Golang / MongoDB	20
DELETE /links	Node.js / PostgreSQL	47
	Node.js / MongoDB	8
	Golang / PostgreSQL	62
	Golang / MongoDB	7
E2E (End to End)	Node.js / PostgreSQL	0.88
	Node.js / MongoDB	0.17
	Golang / PostgreSQL	0.95
	Golang / MongoDB	0.9
E2E (End to End) tanpa login	Node.js / PostgreSQL	21
	Node.js / MongoDB	2.7
	Golang / PostgreSQL	15
	Golang / MongoDB	1.9

Kombinasi Terbaik: Golang dengan PostgreSQL menunjukkan performa terbaik dalam iterasi per detik saat breakpoint testing, diikuti oleh Golang dengan MongoDB, Node.js dengan PostgreSQL, dan Node.js dengan MongoDB. API dengan Golang umumnya lebih unggul daripada Node.js.
Performa Golang pada Beban Tinggi: Golang menunjukkan kinerja yang lebih baik saat menerima beban tinggi. Meskipun tidak selalu unggul dalam setiap pengujian dibandingkan dengan Node.js pada basis data yang sama, selisih iterasi per detiknya tidak terlalu besar. Dari 8 skenario pengujian, Golang unggul dalam 5 skenario dan 1 skenario memiliki hasil yang sama dengan Node.js menggunakan PostgreSQL. Dengan MongoDB, Golang unggul dalam 3 skenario dengan selisih yang signifikan.
Keunggulan PostgreSQL: PostgreSQL consistently menghasilkan performa lebih tinggi dibandingkan MongoDB dalam pengujian breakpoint, dengan nilai akhir yang lebih tinggi di semua skenario.
Rataan Iterasi Rendah pada Login: Pengujian login memiliki rataan iterasi terendah karena prosesnya yang berat. Hal ini diperkuat oleh data E2E testing, di mana E2E tanpa login menghasilkan iterasi yang jauh lebih banyak dibandingkan dengan E2E menggunakan login, dengan selisih sekitar 25 iterasi per detik.
Kesamaan Nilai pada E2E dengan Login: Pengujian E2E dengan login untuk load dan spike menggunakan nilai yang sama untuk semua jenis API dan basis data. Hal ini karena sistem K6 hanya memungkinkan pengujian iterasi per detik minimal satu, sementara pada pengujian breakpoint, semua skenario memiliki nilai di bawah satu. Pengujian dengan target yang sama memberikan perbandingan yang valid dalam hal penggunaan CPU dan memori di semua servis dan jenis basis data.

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Servis/ Basis Data	Load	Spike
Node.js / PostgreSQL	21	42
Node.js / MongoDB	8	16
Golang / PostgreSQL	32	64
Golang / MongoDB	20	40

Secara pencapaian yang didapatkan selama pengujian Breakpoint untuk mendapatkan nilai tertinggi yang akan digunakan pada Load & Spike Testing, Golang dengan PostgreSQL menjadi kombinasi yang mendapatkan nilai median tertinggi dari semua pengujian yang dilakukan yang berarti kombinasi tersebut yang dapat memproses data paling baik.

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Servis	Load	Spike
Node.js Express	14	28
Golang Gin	15	30

Hasil nilai median dari keseluruhan pengujian memberikan Golang Gin unggul secara tipis daripada Node.js Express

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Basis Data	Load	Spike
Postgresql	26.5	53
MongoDB	8	16

Berbeda pada hasil berdasarkan framework, ketika dibandingkan berdasarkan Database yang digunakan. Terlihat perbedaan signifikan berdasarkan hasil yang diberikan untuk nilai median dari nilai yang didapatkan pada semua pengujian breakpoint.

Nilai Utilisasi CPU & Memori

Dalam tabel yang tersedia merupakan nilai median penggunaan CPU dan Memori yang digunakan oleh kombinasi sistem, framework, dan database selama pengujian berlangsung. Semakin kecil nilai yang didapatkan maka semakin baik performa yang dihasilkan karena berarti semakin efisien.

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Beban yang digunakan pada Load & Spike Testing didasarkan pada hasil Breakpoint Testing Sebelumnya

Skenario	Servis / Basis Data	Load		Spike
Skenario	Servis / Basis Data	CPU (%)	Memory (%)	CPU (%)	Memory (%)
POST /login	Node.js / PostgreSQL	88,55	25,28	84,88	23,87
	Node.js / MongoDB	84,5	21,15	84,91	22,94
	Golang / PostgreSQL	62,57	6,54	64,46	6,45
	Golang / MongoDB	92,31	6,70	70,05	6.48
GET /links	Node.js / PostgreSQL	57,30	28,01	76,67	26,50
	Node.js / MongoDB	21,64	29,44	38,32	34,71
	Golang / PostgreSQL	13,5	4,48	20,56	6,53
	Golang / MongoDB	6,61	6,27	7,45	6,78
GET /{short-link}	Node.js / PostgreSQL	12,39	24,7	19,54	25,05
	Node.js / MongoDB	10,44	25,49	11,31	26,29
	Golang / PostgreSQL	27,26	6,77	54,28	7,47
	Golang / MongoDB	7,30	5,89	8,51	8,39
POST /links	Node.js / PostgreSQL	22,55	24,88	39,81	24,57
	Node.js / MongoDB	12,95	26,71	12,96	24,52
	Golang / PostgreSQL	21,95	4,04	35,99	7,35
	Golang / MongoDB	8,23	8,60	7,62	8,5
PATCH /links	Node.js / PostgreSQL	8,57	24,22	25,81	25,75
	Node.js / MongoDB	5,86	24,22	8,74	25,47
	Golang / PostgreSQL	10,03	6,39	14,1	7,56
	Golang / MongoDB	8,89	6,40	10,07	6,91
GET /links/self	Node.js / PostgreSQL	27,34	25,28	52,57	25,58
	Node.js / MongoDB	11,04	38,61	10,59	34,01
	Golang / PostgreSQL	13,36	6,63	24,03	6,69
	Golang / MongoDB	7,56	6,48	8,24	8,14
DELETE /links	Node.js / PostgreSQL	32,70	24,76	23,24	25,13
	Node.js / MongoDB	7,5	24,70	13,51	27,06
	Golang / PostgreSQL	47,80	7,19	21,88	7,65
	Golang / MongoDB	8,63	6,83	8,15	8,50
E2E (End to End)	Node.js / PostgreSQL	83,19	24,32	84,17	21,50
	Node.js / MongoDB	81,56	48,50	86,45	44,77
	Golang / PostgreSQL	61,58	6,49	53,34	6,60
	Golang / MongoDB	65,95	6,65	67,18	6,48
E2E (End to End) tanpa login	Node.js / PostgreSQL	36,42	24,77	61,23	23,12
	Node.js / MongoDB	7,83	25,21	13,40	26,29
	Golang / PostgreSQL	27,38	7,44	29,48	7,76
	Golang / MongoDB	7,12	6,59	4,80	6,10

Servis/ Basis Data	Load			Spike
Servis/ Basis Data	CPU	Memory	Ips	CPU	Memory	Ips
Node.js / PostgreSQL	32.7%	24.77%	21	52.57%	25.05%	42
Node.js / MongoDB	11.04%	24.70%	8	12.96%	26.29%	16
Golang / PostgreSQL	21.95%	6.54%	32	24.03%	7.35%	64
Golang / MongoDB	8.23%	6.48%	20	8.24%	8.14%	40

Utilisasi Memori: Secara umum, penggunaan memori tiap servis tidak terlalu dipengaruhi oleh jumlah iterasi per detik dan jenis basis data. Golang menunjukkan penggunaan memori yang lebih efisien dengan median 7,319%, jauh lebih rendah dibandingkan dengan Node.js yang mencapai 25,04%, atau sekitar 3 kali lebih tinggi.
Rataan Breakpoint dan Utilisasi CPU: Golang cenderung menghasilkan lebih banyak iterasi per detik dalam pengujian breakpoint. Pada pengujian load dan spike, Golang juga lebih efisien dengan median utilisasi CPU sebesar 17,57%, lebih rendah dibandingkan Node.js yang mencapai 22,09%, menunjukkan bahwa Golang dapat memproses lebih banyak data dengan sumber daya yang lebih sedikit.
Kenaikan Utilisasi CPU: Golang menunjukkan kenaikan persentase median utilisasi CPU yang lebih rendah, yaitu 30,64%, meskipun secara umum melakukan lebih banyak iterasi per detik. Node.js memiliki kenaikan lebih tinggi, yakni 45,12%.
Kenaikan Utilisasi Memori: Dalam pengujian load ke spike, Node.js mengalami kenaikan median utilisasi memori sebesar 1,92%, sementara Golang naik sebesar 5,3%. Meskipun demikian, nilai absolut utilisasi memori Node.js masih jauh lebih tinggi, dengan median spike mencapai 25,53% dibandingkan dengan Golang yang hanya 7,7%.
Perbandingan SQL dan NoSQL: PostgreSQL menunjukkan median utilisasi CPU yang lebih tinggi dibandingkan MongoDB, dengan nilai pada load sebesar 27,36% dan spike sebesar 37,9%. MongoDB lebih efisien dengan utilisasi CPU pada load sebesar 8,76% dan spike sebesar 10,33%, serta memori load sebesar 7,71% dan spike sebesar 8,5% berbanding pada PostgreSQL 27,36% cpu dan 37,9%.
Efisiensi PostgreSQL dan MongoDB: Meskipun MongoDB lebih efisien dalam penggunaan CPU dan memori, PostgreSQL menunjukkan performa lebih baik dalam iterasi per detik, dengan median 26,5 dibandingkan 8 pada MongoDB. Pada pengujian E2E, PostgreSQL kurang efisien dibandingkan MongoDB. Namun, PostgreSQL cenderung lebih baik dalam memproses data lebih cepat di semua servis, baik Golang maupun Node.js, karena iterasi per detiknya yang lebih tinggi.

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Servis/ Basis Data	Load			Spike
Servis/ Basis Data	CPU	Memory	Ips	CPU	Memory	Ips
Node.js / PostgreSQL	32.7%	24.77%	21	52.57%	25.05%	42
Node.js / MongoDB	11.04%	24.70%	8	12.96%	26.29%	16
Golang / PostgreSQL	21.95%	6.54%	32	24.03%	7.35%	64
Golang / MongoDB	8.23%	6.48%	20	8.24%	8.14%	40

Hasil pengujian menunjukkan bahwa kombinasi Golang dengan PostgreSQL memberikan kinerja terbaik dalam pengujian beban dan spike, dengan penggunaan CPU dan memori yang lebih rendah, serta jumlah iterasi per detik yang lebih tinggi dibandingkan dengan kombinasi lainnya. Sebaliknya, kombinasi Node.js dengan MongoDB menunjukkan kinerja yang paling rendah dalam kedua skenario, terutama dalam hal jumlah iterasi per detik yang dihasilkan. Hal ini menyoroti efisiensi yang lebih tinggi dari Golang dan PostgreSQL dalam menangani permintaan yang berat dan tiba-tiba.

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Servis	Load			Spike
Servis	CPU	Memory	Ips	CPU	Memory	Ips
Node.js Express	22.09%	24.82%	14	32.07%	25.53%	28
Golang Gin	17.57%	7.31%	15	22.95%	7.71%	30

Berdasarkan nilai yang didapat pada pengujian, Golang dapat memproses lebih banyak iterasi per detik dengan penggunaan CPU lebih rendah dibanding Node.js (17,57% vs 22,09%). Golang menunjukkan kenaikan persentase kenaikan utilisasi CPU dari load ke spike testing yang lebih rendah (30,64%) dibanding Node.js (45,12%) meskipun memproses lebih banyak iterasi per detik. Walaupun persentase kenaikan memori lebih tinggi pada Golang (5,3% vs 2,83% di Node.js), penggunaan memori Node.js saat spike testing tetap jauh lebih tinggi (25,53% vs 7,7%).

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Basis Data	Load			Spike
Basis Data	CPU	Memory	Ips	CPU	Memory	Ips
Postgresql	27.35%	15.83%	26.5	37.9%	14.63%	53
MongoDB	8.76%	7.71%	8	10.33%	8.5%	16

Berdasarkan hasil, PostgreSQL menggunakan lebih banyak CPU dan memori dibandingkan MongoDB selama load dan spike testing, dengan nilai median CPU 27,36% dan 37,9% serta memori 27,36% dan 37,9%, sementara MongoDB hanya menggunakan 8,76% dan 10,33% untuk CPU, serta 7,71% dan 8,5% untuk memori. Meskipun MongoDB terlihat lebih efisien, PostgreSQL sebenarnya memproses lebih banyak iterasi per detik (median 26,5 vs 8 pada MongoDB) selama load testing.

Perbandingan Performa Get Single Link

Pemilihan endpoint Get Single Link dikarenakan merupakan endpoint yang mendapatkan nilai iterasi per detik paling tinggi pada semua skenario sistem.

Catatan: Beban pengujian berturut yang diberikan Node.js/PostgreSQL (68), Node.js/MongoDB (47), Golang/PostgreSQL (81), dan Golang/MongoDB (69) merupakan beban pada Load Testing dengan berarti dua kali lipat diberikan pada Spike Testing

Servis/ Basis Data	Load			Spike
Servis/ Basis Data	Median	P95	%	Median	P95	%
Node.js / PostgreSQL	83ms	146ms	100%	147ms	1s	94%
Node.js / MongoDB	81ms	136ms	99%	10s	16s	78%
Golang / PostgreSQL	193ms	398ms	99%	416ms	1s	99%
Golang / MongoDB	8s	16s	77%	4s	16s	40%

Hasil pengujian menunjukkan bahwa kombinasi Golang dengan PostgreSQL memiliki performa terbaik dibandingkan dengan tiga kombinasi lainnya. Golang dengan PostgreSQL mencatatkan iterasi per detik tertinggi, dengan tingkat keberhasilan permintaan 99% pada pengujian load dan spike. Meskipun terdapat beberapa kegagalan kecil, performa ini tetap lebih baik dibandingkan Node.js yang mencatat 100% keberhasilan pada load testing, namun mengalami 6% kegagalan pada spike testing. Secara keseluruhan, Golang menunjukkan ketahanan maksimal yang lebih tinggi dan kemampuan memproses permintaan lebih banyak per detik (81 vs 68), meskipun waktu pemrosesannya sedikit lebih lama dibandingkan Node.js.

Perbandingan Performa E2E tanpa Login

Membandingkan hasil E2E tanpa login dikarenakan pada pengujian ini semua skenario sistem diberikan beban maksimal yang sama. Sehingga dapat melihat bagaimana perilaku tiap skenario sistem yang diuji ketika beban yang diberikan adalah sama.

RPS (Request per second) Jumlah permintaan yang dilakukan saat pengujian dalam setiap detik.

Servis/ Basis Data	Load			Spike
Servis/ Basis Data	Median	P95	%	Median	P95	%
Node.js / PostgreSQL	4.72s	12.86s	13.96%	6s	14.9s	5.64%
Node.js / MongoDB	10.5s	40.49s	6.7%	21s	57.8s	3%
Golang / PostgreSQL	229ms	10s	9%	431ms	14.3s	4.17%
Golang / MongoDB	900ms	10.6s	9.67%	1.4s	15s	3.77%

Persentase keberhasilan pengujian menunjukkan bahwa Node.js dengan PostgreSQL memiliki hasil terbaik pada load dan spike testing. Namun, Golang memberikan performa yang lebih konsisten pada kedua database, dengan nilai median dan p95 yang umumnya lebih baik daripada Node.js. Nilai median dan p95 ini didasarkan pada durasi pemrosesan permintaan per detik, dengan satu iterasi pengujian terdiri dari 7 permintaan.

IPS (Iteration per second) Jumlah iterasi yang dilakukan saat pengujian dalam setiap detik, dimana memungkinkan dalam satu iterasi terdapat lebih dari 1 request/permintaan yang dilakukan

Servis/ Basis Data	Load		Spike
Servis/ Basis Data	Median	P95	Median	P95
Node.js / PostgreSQL	6.77s	28.83s	638ms	18s
Node.js / MongoDB	7.57s	72s	904ms	68s
Golang / PostgreSQL	5.11s	18.1s	556ms	15.24s
Golang / MongoDB	6.83s	20.97s	1s	17.7s

Hasil perhitungan pada iterasi menunjukkan peningkatan signifikan, terutama saat load testing. Peningkatan ini terjadi karena ada satu endpoint, yaitu login, yang membutuhkan waktu lebih lama untuk diproses. Secara umum, Golang menunjukkan performa lebih baik dan stabil pada semua basis data yang digunakan dibandingkan dengan Node.js.

Perbandingan Waktu Pemrosesan Sistem

Waktu pemrosesan permintaan per detik pada kombinasi setiap sistem yang diuji.

Catatan: Nilai Median Beban pengujian Load pada setiap sistem secara berturut pada Node.js/PostgreSQL (21), Node.js/MongoDB (8), Golang/PostgreSQL (32), dan Golang/MongoDB (20) merupakan beban pada Load Testing dengan berarti dua kali lipat diberikan pada Spike Testing

Servis/ Basis Data	Load		Spike
Servis/ Basis Data	Median	P95	Median	P95
Node.js / PostgreSQL	147ms	270ms	1,3s	7s
Node.js / MongoDB	644ms	1,28s	6,1s	16,5s
Golang / PostgreSQL	193ms	355ms	252ms	1s
Golang / MongoDB	1,75s	7s	6s	14s

Hasilnya menunjukkan bahwa Golang dengan PostgreSQL kembali menghasilkan performa terbaik secara keseluruhan. Kombinasi ini sebelumnya juga memiliki median tertinggi dalam pengujian breakpoint, yang berarti mampu menangani lebih banyak permintaan. Meskipun pada pengujian Load Testing, Golang PostgreSQL sedikit di bawah Node.js PostgreSQL karena versi Node.js memproses lebih sedikit permintaan per detik, hasil pengujian Spike Testing menunjukkan bahwa Golang PostgreSQL tetap unggul. Kombinasi ini mampu menangani banyak permintaan dengan baik, bahkan saat beban permintaan sangat tinggi, melebihi sistem lainnya.

Melakukan pengujian performa API menggunakan K6

Pendahuluan

Skenario Sistem

Bahan Uji

Alat Pengujian

Jenis Pengujian

Pengembangan API

Pengembangan Bahan Uji API (Application Programming Interfaces)

Dokumentasi API

Pengujian Performa API

Skenario Pengujian

Smoke Testing

Breakpoint Testing

Load Testing

Spike Testing

Jenis Pengujian

Skenario Pengujian

Detail Skenario

Total Waktu Pengujian

Penulisan Skrip Pengujian

Skrip Pengujian

Pengujian

Hasil Pengujian

Analisis

Nilai Pengujian Breakpoint, Load, dan Spike

Nilai Utilisasi CPU & Memori

Perbandingan Performa Get Single Link

Perbandingan Performa E2E tanpa Login

Perbandingan Waktu Pemrosesan Sistem

Hasil Akhir

Golang lebih baik dari Node.js

Postgresql lebih baik dari MongoDB

Kombinasi Golang Postgresql hasilkan performa terbaik

Golang Postgresql memberikan performa baik dan stabil pada perbandingan beban yang sama

Hasil dan Rekomendasi