{"id":1271,"date":"2026-05-24T01:01:10","date_gmt":"2026-05-23T18:01:10","guid":{"rendered":"https:\/\/www.jakhoster.com\/blog\/benchmarking-performa-docker-adalah\/"},"modified":"2026-05-24T01:08:11","modified_gmt":"2026-05-23T18:08:11","slug":"benchmarking-performa-docker-adalah","status":"publish","type":"post","link":"https:\/\/www.jakhoster.com\/blog\/benchmarking-performa-docker-adalah\/","title":{"rendered":"Benchmarking Performa Docker : Optimalisasi Resource pada VPS dengan Penggunaan Nyata"},"content":{"rendered":"

Memahami Konteks Penggunaan Docker dalam Lingkungan Produksi<\/h2>\n

Dalam dunia pengembangan perangkat lunak modern, Docker telah menjadi pilihan utama bagi banyak perusahaan untuk mengelola aplikasi mereka. Namun, baru-baru ini, seorang teman saya yang bekerja di sebuah startup menghadapi masalah serius ketika beban server mereka meningkat pesat selama peluncuran produk baru. Server yang mereka gunakan mengalami downtime akibat tidak mampu menangani traffic yang tinggi. Setelah investigasi, mereka menyadari bahwa konfigurasi Docker mereka tidak dioptimalkan untuk kondisi tersebut. Di sini, kita akan membahas secara mendalam tentang docker adalah<\/strong> dan bagaimana melakukan benchmarking performa serta optimasi resource pada VPS.<\/p>\n

Apa Itu Docker?<\/h2>\n

Docker adalah platform yang memungkinkan developer untuk membangun, mengirim, dan menjalankan aplikasi dalam kontainer. Kontainer memungkinkan aplikasi dan semua dependensinya dikemas bersama-sama, sehingga aplikasi dapat berjalan secara konsisten di berbagai lingkungan. Dengan kata lain, docker adalah<\/strong> alat yang menghadirkan solusi efisien untuk masalah ‘works on my machine’.<\/p>\n

Benchmarking Performa: Apa dan Mengapa?<\/h2>\n

Benchmarking performa adalah proses pengukuran efisiensi dan kecepatan dari aplikasi yang berjalan di dalam kontainer Docker. Ini penting untuk memastikan bahwa aplikasi dapat menangani beban kerja yang diharapkan. Dalam kasus saya, startup tersebut harus melakukan benchmarking untuk mengidentifikasi bottleneck dan memperbaiki inefisiensi. Kita akan menggunakan alat seperti Docker Stats<\/strong> dan cAdvisor<\/strong> untuk memantau penggunaan resource serta kinerja aplikasi.<\/p>\n

Sebagai langkah lanjutan untuk memahami pengelolaan aplikasi yang lebih kompleks, Anda bisa menyimak artikel “Mengenal Multi Container Docker<\/a>“.<\/p>\n

Alat yang Digunakan untuk Benchmarking<\/h3>\n

Kita akan menggunakan beberapa alat untuk memantau dan mengukur performa aplikasi dalam kontainer Docker:<\/p>\n

    \n
  • Docker Stats:<\/strong> Menyediakan statistik real-time dari kontainer yang berjalan, mengukur CPU, memori, I\/O, dan jaringan.<\/li>\n
  • cAdvisor:<\/strong> Alat dari Google yang memberikan informasi mendalam mengenai penggunaan resource kontainer dan dapat diintegrasikan dengan Prometheus untuk analisis lebih lanjut.<\/li>\n
  • Apache Benchmark (ab):<\/strong> Alat untuk mengukur kinerja HTTP, berguna untuk menguji ratusan permintaan sekaligus.<\/li>\n
  • JMeter:<\/strong> Alat testing beban yang dapat digunakan untuk menguji aplikasi web dan menyediakan laporan kinerja yang mendetail.<\/li>\n<\/ul>\n

    Langkah-Langkah Melakukan Benchmarking<\/h2>\n

    Setelah memilih alat yang tepat, <\/p>\n

    1. Mempersiapkan Kontainer<\/h3>\n

    Kita harus memastikan bahwa kontainer yang ingin diuji berjalan dengan baik. Pertama-tama, mari kita jalankan kontainer menggunakan Docker Compose. <\/p>\n

    version: '3.8'\nservices:\n  app:\n    image: node:14\n    volumes:\n      - .:\/usr\/src\/app\n    working_dir: \/usr\/src\/app\n    command: npm start\n    ports:\n      - '3000:3000'<\/code><\/pre>\n
    Pada file ini, volumes<\/code> digunakan untuk memetakan direktori lokal ke dalam kontainer, dan command<\/code> menjalankan aplikasi Node.js. Setelah itu, jalankan perintah berikut:<\/p>\n
    docker-compose up -d<\/code><\/pre>\n
    Perintah ini akan menjalankan semua layanan di latar belakang.<\/p>\n
    2. Menggunakan Docker Stats untuk Memantau Resource<\/h3>\n
    Setelah kontainer berjalan, kita dapat memantau penggunaan resource dengan docker stats<\/code>. Jalankan perintah berikut:<\/p>\n
    docker stats<\/code><\/pre>\n
    Perintah ini akan menampilkan tabel real-time dari penggunaan CPU, memori, dan I\/O dari semua kontainer yang berjalan. Cermati angka-angka tersebut untuk mengidentifikasi apakah ada kontainer yang menggunakan resource berlebih.<\/p>\n
    3. Menguji Kinerja Menggunakan Apache Benchmark<\/h3>\n
    Sekarang kita akan menguji performa aplikasi menggunakan Apache Benchmark. Jalankan perintah berikut untuk menguji 1000 permintaan dengan 10 permintaan bersamaan:<\/p>\n
    ab -n 1000 -c 10 http:\/\/localhost:3000\/<\/code><\/pre>\n
    Keterangan parameter:<\/p>\n
      \n
    • -n 1000:<\/code> Jumlah total permintaan yang akan dilakukan.<\/li>\n
    • -c 10:<\/code> Jumlah permintaan yang akan dilakukan secara bersamaan.<\/li>\n<\/ul>\n
      Setelah pengujian selesai, Anda akan melihat statistik seperti waktu rata-rata yang dibutuhkan untuk menyelesaikan setiap permintaan, jumlah permintaan yang berhasil, dan berapa banyak yang gagal.<\/p>\n
      4. Menganalisis Hasil<\/h3>\n
      Setelah mendapatkan hasil dari pengujian, analisis metrik seperti:<\/p>\n
        \n
      • Waktu Respons:<\/strong> Jika waktu respons terlalu tinggi, Anda mungkin perlu memeriksa pengaturan aplikasi atau melakukan optimisasi lebih lanjut.<\/li>\n
      • Throughput:<\/strong> Menunjukkan berapa banyak permintaan yang dapat ditangani dalam satu detik. Jika angka ini rendah, pertimbangkan untuk menambah resource atau melakukan scaling.<\/li>\n
      • Persentase Kesalahan:<\/strong> Memastikan bahwa tidak ada permintaan yang gagal menjadi indikator kesehatan sistem.<\/li>\n<\/ul>\n
        Optimalisasi dan Scaling Aplikasi Docker<\/h2>\n
        Setelah melakukan benchmarking, Anda mungkin menemukan bahwa aplikasi perlu dioptimalisasi untuk performa yang lebih baik. Mari kita bahas beberapa langkah untuk mencapai itu:<\/p>\n
        1. Mengoptimalkan Docker Image<\/h3>\n
        Dengan menggunakan multi-stage builds<\/strong>, Anda dapat mengurangi ukuran image kontainer dan mempercepat waktu startup. Berikut ini adalah contoh Dockerfile yang menggunakan multi-stage build:<\/p>\n
        FROM node:14 AS build\nWORKDIR \/usr\/src\/app\nCOPY package*.json .\/\nRUN npm install\nCOPY . .\nRUN npm run build\n\nFROM node:14\nWORKDIR \/usr\/src\/app\nCOPY --from=build \/usr\/src\/app\/build .\/build\nCMD ['npm', 'start']<\/code><\/pre>\n
        Di sini, kita membangun aplikasi di tahap pertama dan hanya menyalin hasil build ke tahap kedua, mengurangi ukuran akhir image.<\/p>\n
        2. Menggunakan Docker Compose untuk Auto Scaling<\/h3>\n
        Anda dapat menggunakan Docker Compose untuk mengatur skala otomatis dengan menambahkan pengaturan replicas<\/code> dalam file Compose Anda:<\/p>\n
        version: '3.8'\nservices:\n  app:\n    image: node:14\n    deploy:\n      replicas: 3\n    ports:\n      - '3000:3000'<\/code><\/pre>\n
        Dengan menambah jumlah replicas<\/code>, lebih banyak instansi kontainer yang akan dijalankan, meningkatkan kemampuan aplikasi untuk menangani lebih banyak traffic.<\/p>\n
        3. Mengatur Load Balancer<\/h3>\n
        Dalam lingkungan produksi, menggunakan load balancer seperti NGINX atau Traefik dapat membantu mendistribusikan traffic secara merata di antara kontainer. <\/p>\n
        http {\n  upstream app {\n    server app1:3000;\n    server app2:3000;\n  }\n  server {\n    listen 80;\n    location \/ {\n      proxy_pass http:\/\/app;\n    }\n  }\n}<\/code><\/pre>\n
        Konfigurasi ini secara otomatis mendistribusikan traffic ke dua server di dalam upstream app<\/code>.<\/p>\n
        Common Mistakes dan Solusinya<\/h2>\n
        Saat mengkonfigurasi Docker untuk lingkungan produksi, ada beberapa kesalahan umum yang sering terjadi:<\/p>\n
          \n
        • Ukuran Image yang Terlalu Besar:<\/strong> Pastikan untuk menggunakan base image yang ringan dan melakukan multi-stage build seperti dibahas sebelumnya.<\/li>\n
        • Tidak Mengatur Batas Resource:<\/strong> Tanpa pengaturan batas resource seperti mem_limit<\/code>, kontainer dapat menggunakan terlalu banyak resource, mengakibatkan kegagalan sistem. Sebagai contoh:<\/li>\n
          services:\n  app:\n    deploy:\n      resources:\n        limits:\n          cpus: '0.5'\n          memory: '512M'<\/code><\/pre>\n
        • Kontainer yang Tidak Dipantau:<\/strong> Pastikan untuk memantau performa kontainer secara real-time menggunakan cAdvisor atau alat monitoring lainnya.<\/li>\n<\/ul>\n
          Penutup<\/h2>\n
          Benchmarking performa dan optimalisasi resource di Docker adalah langkah penting untuk memastikan aplikasi berjalan dengan efisien di lingkungan produksi. Dengan mengikuti langkah-langkah di atas dan menghindari kesalahan umum, Anda dapat meningkatkan kinerja aplikasi, menjaga keandalannya, dan memaksimalkan pemanfaatan resource. Pengalaman saya di lapangan menunjukkan bahwa pendekatan sistematis seperti ini membantu dalam mencapai hasil yang lebih baik dan mencegah masalah di kemudian hari.<\/p>\n","protected":false},"excerpt":{"rendered":"
          Pelajari bagaimana cara melakukan benchmarking performa Docker pada server VPS, optimasi resource, dan implementasi nyata dalam lingkungan produksi.<\/p>\n","protected":false},"author":2,"featured_media":1270,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[87],"tags":[],"class_list":["post-1271","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-docker"],"_links":{"self":[{"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/posts\/1271","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/comments?post=1271"}],"version-history":[{"count":1,"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/posts\/1271\/revisions"}],"predecessor-version":[{"id":1275,"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/posts\/1271\/revisions\/1275"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/media\/1270"}],"wp:attachment":[{"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/media?parent=1271"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/categories?post=1271"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.jakhoster.com\/blog\/wp-json\/wp\/v2\/tags?post=1271"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}