Membuat HTTP Server dengan JavaScript Tanpa Framework

1. Mengapa JavaScript Bisa Digunakan untuk Backend?#

Pada seri JavaScript sebelumnya, kita menjalankan kode melalui browser.

Contohnya:

1
document.querySelector("button");

Kode tersebut menggunakan DOM API yang disediakan browser.

Namun, JavaScript tidak hanya bisa dijalankan di browser.

Dengan runtime seperti Node.js, kita bisa menjalankan JavaScript langsung pada komputer atau server.

Node.js menyediakan berbagai modul bawaan, termasuk kemampuan untuk:

• Membaca dan menulis file.
• Menjalankan proses.
• Berkomunikasi melalui jaringan.
• Membuat HTTP server.

Artinya, kita dapat membuat backend menggunakan bahasa JavaScript yang sudah dipelajari sebelumnya.

Perbedaannya terletak pada lingkungan tempat kode dijalankan.

2. Apa Itu Node.js?#

Node.js adalah runtime JavaScript yang memungkinkan kode JavaScript dijalankan di luar browser.

Salah satu penggunaannya adalah membangun aplikasi server.

Node.js bukan framework dan bukan bahasa pemrograman baru.

Kita tetap menulis JavaScript.

Sebagai contoh, kode berikut dapat dijalankan menggunakan Node.js:

1
const nama = "BapakGabut";
2

3
console.log(`Halo, ${nama}!`);

Simpan sebagai:

1
halo.js

Lalu jalankan melalui terminal:

1
node halo.js

Hasilnya:

1
Halo, BapakGabut!

Tidak diperlukan browser untuk menjalankan kode tersebut.

3. Menginstal Node.js#

Sebelum membuat server, kita perlu memastikan Node.js sudah tersedia di komputer.

Kunjungi website resmi:

https://nodejs.org/

Unduh versi LTS (Long-Term Support) yang tersedia.

Versi LTS umumnya menjadi pilihan yang cocok untuk pembelajaran dan penggunaan yang mengutamakan stabilitas.

Ikuti proses instalasi sesuai sistem operasi yang digunakan.

Setelah selesai, buka terminal.

Pada Windows, kita bisa menggunakan PowerShell atau Command Prompt.

Pada macOS atau Linux, gunakan aplikasi Terminal.

Jalankan:

1
node --version

Jika Node.js terpasang dengan benar, terminal akan menampilkan nomor versi.

Contohnya:

1
vXX.YY.ZZ

Nomor versi yang muncul dapat berbeda tergantung versi yang diinstal.

Kita juga bisa memeriksa npm:

1
npm --version

npm merupakan package manager yang biasanya disertakan dalam instalasi Node.js.

Namun, untuk artikel ini, kita tidak perlu memasang package tambahan.

Jika perintah node tidak dikenali, periksa apakah instalasi berhasil dan apakah lokasi Node.js sudah tersedia pada PATH sistem.

Setelah melakukan instalasi, terkadang kita perlu menutup dan membuka kembali terminal.

4. Menyiapkan Folder Proyek#

Buat folder baru:

1
belajar-http-server/

Di dalamnya, buat file:

1
server.js

Struktur proyek kita sangat sederhana:

1
belajar-http-server/
2
└── server.js

Kita belum membutuhkan package.json, folder node_modules, atau konfigurasi framework.

Semua contoh menggunakan modul bawaan Node.js.

Buka folder tersebut menggunakan editor kode pilihanmu.

5. Mengenal Modul node#

Node.js menyediakan modul bawaan bernama node:http.

Modul ini memungkinkan kita membuat HTTP server.

Untuk menggunakannya, tulis:

1
const http = require("node:http");

Kita menggunakan require() untuk memuat modul dengan sistem CommonJS.

Awalan node: menunjukkan bahwa modul tersebut merupakan modul bawaan Node.js.

Karena sudah tersedia, kita tidak perlu menjalankan:

1
npm install http

Kita langsung bisa menggunakannya.

6. Membuat HTTP Server Pertama#

Sekarang buka file server.js.

Masukkan kode berikut:

1
const http = require("node:http");
2

3
const server = http.createServer((req, res) => {
4
  res.writeHead(200, {
5
    "Content-Type": "text/plain; charset=utf-8"
6
  });
7

8
  res.end("Halo, Gabuters! Ini server JavaScript pertama kita.");
9
});
10

11
server.listen(3000, () => {
12
  console.log("Server berjalan di http://localhost:3000");
13
});

Simpan file tersebut.

Kemudian buka terminal pada folder proyek.

Jalankan:

1
node server.js

Jika berhasil, terminal akan menampilkan:

1
Server berjalan di http://localhost:3000

Sekarang buka browser dan kunjungi:

1
http://localhost:3000

Kita akan melihat:

1
Halo, Gabuters! Ini server JavaScript pertama kita.

Selamat!

Kita baru saja membuat HTTP server menggunakan JavaScript tanpa framework.

7. Memahami Kode HTTP Server#

Mari kita bedah bagian-bagiannya.

1
const http = require("node:http");

1
const server = http.createServer((req, res) => {
2
  // Menangani request
3
});

1
res.writeHead(200, {
2
  "Content-Type": "text/plain; charset=utf-8"
3
});

1
res.end("Halo, Gabuters!");

1
server.listen(3000, () => {
2
  console.log("Server berjalan di http://localhost:3000");
3
});

8. Apa Itu localhost dan Port?#

Ketika membuka:

1
http://localhost:3000

Ada dua bagian yang perlu dipahami.

1
3000

1
server.listen(4000);

1
http://localhost:4000

1
server.listen(3000, "127.0.0.1");

9. Mengenal req dan res#

Dua objek yang paling penting dalam HTTP server Node.js adalah req dan res.

1
console.log(req.method);
2
console.log(req.url);

1
res.statusCode = 200;
2
res.setHeader("Content-Type", "text/plain; charset=utf-8");
3
res.end("Request berhasil diproses.");

1
req = informasi yang masuk
2
res = jawaban yang dikirim

10. Membaca URL yang Diminta#

Sekarang kita buat server yang menampilkan path request.

Ganti isi server.js dengan:

1
const http = require("node:http");
2

3
const server = http.createServer((req, res) => {
4
  console.log("Method:", req.method);
5
  console.log("URL:", req.url);
6

7
  res.writeHead(200, {
8
    "Content-Type": "text/plain; charset=utf-8"
9
  });
10

11
  res.end(`Kamu mengakses: ${req.url}`);
12
});
13

14
server.listen(3000, "127.0.0.1", () => {
15
  console.log("Server berjalan di http://localhost:3000");
16
});

Jalankan kembali server:

1
node server.js

Buka:

1
http://localhost:3000/profil

Browser akan menampilkan:

1
Kamu mengakses: /profil

Terminal juga akan mencatat method dan URL request.

Contohnya:

1
Method: GET
2
URL: /profil

Coba akses:

1
http://localhost:3000/artikel

Hasilnya akan berubah menjadi:

1
Kamu mengakses: /artikel

Dari sini, kita mulai melihat bagaimana server membedakan alamat yang diminta client.

11. Membuat Routing Sederhana#

Routing adalah proses menentukan tindakan berdasarkan request yang diterima.

Untuk latihan pertama, kita dapat menggunakan percabangan if.

Ganti isi server.js dengan:

1
const http = require("node:http");
2

3
const server = http.createServer((req, res) => {
4
  res.setHeader("Content-Type", "text/plain; charset=utf-8");
5

6
  if (req.method === "GET" && req.url === "/") {
7
    res.statusCode = 200;
8
    res.end("Selamat datang di BapakGabut!");
9
    return;
10
  }
11

12
  if (req.method === "GET" && req.url === "/profil") {
13
    res.statusCode = 200;
14
    res.end("Ini adalah halaman profil BapakGabut.");
15
    return;
16
  }
17

18
  if (req.method === "GET" && req.url === "/tentang") {
19
    res.statusCode = 200;
20
    res.end("Kita sedang belajar backend JavaScript.");
21
    return;
22
  }
23

24
  res.statusCode = 404;
25
  res.end("Halaman tidak ditemukan.");
26
});
27

28
server.listen(3000, "127.0.0.1", () => {
29
  console.log("Server berjalan di http://localhost:3000");
30
});

Sekarang kita mempunyai tiga endpoint:

Jika kita membuka:

1
http://localhost:3000/profil

Server mengirim:

1
Ini adalah halaman profil BapakGabut.

Jika kita membuka:

1
http://localhost:3000/tidak-ada

Server mengirim:

1
Halaman tidak ditemukan.

Dengan status:

1
404 Not Found

1
res.end("Selamat datang di BapakGabut!");
2
return;

12. Mengembalikan Data JSON#

Sejauh ini, server kita hanya mengirim teks biasa.

Padahal, API sering mengembalikan JSON.

Mari kita coba.

Ganti isi server.js dengan:

1
const http = require("node:http");
2

3
const server = http.createServer((req, res) => {
4
  if (req.method === "GET" && req.url === "/api/profil") {
5
    const profil = {
6
      nama: "BapakGabut",
7
      tagline: "Ngoding, main game, dan ngulik apa saja.",
8
      minat: ["JavaScript", "Web Development", "Gaming"]
9
    };
10

11
    res.writeHead(200, {
12
      "Content-Type": "application/json; charset=utf-8"
13
    });
14

15
    res.end(JSON.stringify(profil));
16
    return;
17
  }
18

19
  res.writeHead(404, {
20
    "Content-Type": "application/json; charset=utf-8"
21
  });
22

23
  res.end(JSON.stringify({
24
    pesan: "Endpoint tidak ditemukan."
25
  }));
26
});
27

28
server.listen(3000, "127.0.0.1", () => {
29
  console.log("Server berjalan di http://localhost:3000");
30
});

Jalankan server, kemudian buka:

1
http://localhost:3000/api/profil

Kita akan menerima data JSON:

1
{
2
  "nama": "BapakGabut",
3
  "tagline": "Ngoding, main game, dan ngulik apa saja.",
4
  "minat": [
5
    "JavaScript",
6
    "Web Development",
7
    "Gaming"
8
  ]
9
}

Tampilan JSON di browser dapat berbeda.

Ada browser yang menampilkannya sebagai teks, ada pula yang menyediakan tampilan JSON terformat.

Namun, data yang dikirim server tetap berupa JSON.

1
JSON.stringify(profil)

1
res.end();

13. Membuat Endpoint Daftar Artikel#

Sekarang kita buat contoh yang lebih dekat dengan website BapakGabut.

Kita ingin menyediakan endpoint:

1
GET /api/artikel

Endpoint tersebut akan mengembalikan daftar artikel.

Contohnya:

1
const artikel = [
2
  {
3
    id: 1,
4
    judul: "Belajar HTML",
5
    kategori: "HTML"
6
  },
7
  {
8
    id: 2,
9
    judul: "Belajar CSS",
10
    kategori: "CSS"
11
  },
12
  {
13
    id: 3,
14
    judul: "Belajar JavaScript",
15
    kategori: "JavaScript"
16
  }
17
];

Data tersebut masih ditulis langsung di dalam program.

Kita belum menggunakan database.

Untuk membuat response JSON, kita dapat menulis:

1
res.writeHead(200, {
2
  "Content-Type": "application/json; charset=utf-8"
3
});
4

5
res.end(JSON.stringify(artikel));

Pada bagian berikutnya, kita akan menggabungkan endpoint artikel dengan beberapa endpoint lain.

14. Membuat Endpoint Waktu Server#

Selain data artikel, kita juga dapat membuat endpoint yang mengembalikan waktu saat request diproses.

Contohnya:

1
const waktu = new Date().toISOString();

Method toISOString() menghasilkan representasi tanggal dan waktu dalam format ISO 8601 menggunakan UTC.

Misalnya:

1
2026-10-09T12:30:00.000Z

Nilai tersebut hanya contoh.

Waktu sebenarnya bergantung pada saat request diterima.

Kita dapat mengirim data:

1
{
2
  waktuServer: new Date().toISOString()
3
}

Dengan begitu, setiap request dapat menghasilkan nilai waktu yang baru.

15. Menggabungkan Semua Endpoint#

Sekarang kita buat versi akhir server pada artikel ini.

Ganti seluruh isi server.js dengan kode berikut:

1
const http = require("node:http");
2

3
const HOST = "127.0.0.1";
4
const PORT = 3000;
5

6
const artikel = [
7
  {
8
    id: 1,
9
    judul: "Belajar HTML",
10
    kategori: "HTML"
11
  },
12
  {
13
    id: 2,
14
    judul: "Belajar CSS",
15
    kategori: "CSS"
16
  },
17
  {
18
    id: 3,
19
    judul: "Belajar JavaScript",
20
    kategori: "JavaScript"
21
  }
22
];
23

24
function kirimJSON(res, statusCode, data) {
25
  res.writeHead(statusCode, {
26
    "Content-Type": "application/json; charset=utf-8"
27
  });
28

29
  res.end(JSON.stringify(data));
30
}
31

32
const server = http.createServer((req, res) => {
33
  try {
34
    const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
35
    const pathname = url.pathname;
36

37
    console.log(`${req.method} ${pathname}`);
38

39
    if (req.method === "GET" && pathname === "/") {
40
      kirimJSON(res, 200, {
41
        pesan: "Selamat datang di API BapakGabut!"
42
      });
43
      return;
44
    }
45

46
    if (req.method === "GET" && pathname === "/api/profil") {
47
      kirimJSON(res, 200, {
48
        nama: "BapakGabut",
49
        tagline: "Ngoding, main game, dan ngulik apa saja.",
50
        minat: ["JavaScript", "Web Development", "Gaming"]
51
      });
52
      return;
53
    }
54

55
    if (req.method === "GET" && pathname === "/api/artikel") {
56
      kirimJSON(res, 200, artikel);
57
      return;
58
    }
59

60
    if (req.method === "GET" && pathname === "/api/waktu") {
61
      kirimJSON(res, 200, {
62
        waktuServer: new Date().toISOString()
63
      });
64
      return;
65
    }
66

67
    kirimJSON(res, 404, {
68
      pesan: "Endpoint tidak ditemukan."
69
    });
70
  } catch (error) {
71
    console.error("Terjadi error:", error);
72

73
    if (!res.headersSent) {
74
      kirimJSON(res, 500, {
75
        pesan: "Terjadi kesalahan pada server."
76
      });
77
    } else {
78
      res.destroy();
79
    }
80
  }
81
});
82

83
server.on("error", (error) => {
84
  console.error("Server gagal berjalan:", error.message);
85
});
86

87
server.listen(PORT, HOST, () => {
88
  console.log(`Server berjalan di http://localhost:${PORT}`);
89
});

Kode ini merupakan HTTP server sederhana yang mempunyai beberapa endpoint.

Kita juga membuat function kirimJSON() agar tidak perlu menulis header dan JSON.stringify() berulang kali.

1
/api/artikel?kategori=HTML

1
/api/artikel

1
const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
2
const pathname = url.pathname;

16. Mencoba Semua Endpoint#

Jalankan:

1
node server.js

Kemudian coba alamat berikut.

Karena seluruh endpoint menggunakan method GET, kita bisa mencobanya langsung melalui address bar browser.

Untuk memeriksa status code dan header, gunakan tab Network pada Developer Tools.

17. Menguji Server dengan curl#

Selain browser, kita juga bisa menggunakan curl untuk mengirim HTTP request.

Jika curl tersedia, jalankan:

1
curl http://localhost:3000/api/artikel

Kita akan menerima JSON berisi daftar artikel.

Untuk melihat header response, gunakan:

1
curl -i http://localhost:3000/api/artikel

Opsi -i menampilkan header response bersama body.

Kita juga bisa mencoba endpoint yang tidak ditemukan:

1
curl -i http://localhost:3000/tidak-ada

Respons akan mempunyai status 404.

Pada Windows PowerShell, jika perintah curl mempunyai perilaku berbeda karena alias atau konfigurasi shell, kita dapat mencoba curl.exe.

Contohnya:

1
curl.exe -i http://localhost:3000/api/artikel

Untuk latihan ini, kita belum perlu menggunakan tool API khusus.

Browser dan terminal sudah cukup.

18. Menghentikan dan Menjalankan Ulang Server#

Ketika menjalankan:

1
node server.js

Proses Node.js akan tetap aktif untuk menerima request.

Jika kita mengubah kode pada file, proses yang sedang berjalan biasanya tidak otomatis memuat perubahan tersebut.

Untuk menghentikannya, tekan:

1
Ctrl + C

Kemudian jalankan kembali:

1
node server.js

Pada versi Node.js modern, terdapat juga fitur watch mode.

Contohnya:

1
node --watch server.js

Mode ini dapat memulai ulang proses ketika file yang dipantau berubah.

Namun, untuk memahami prosesnya, kita bisa menggunakan cara manual terlebih dahulu.

19. Kesalahan yang Sering Terjadi#

1
node server.js

1
res.end();

1
/api/artikel

1
/api/artikel/

20. Latihan Mandiri#

Sekarang giliran Gabuters mencoba sendiri.

1
GET /api/kategori

1
[
2
  "HTML",
3
  "CSS",
4
  "JavaScript",
5
  "Backend"
6
]

1
GET /api/website

1
{
2
  "nama": "BapakGabut",
3
  "tagline": "Ngoding, main game, dan ngulik apa saja.",
4
  "aktif": true
5
}

1
4000

1
http://localhost:3000/api/artikel?kategori=HTML

1
const kategori = url.searchParams.get("kategori");

1
GET /health

1
{
2
  "status": "ok"
3
}

21. Apa yang Sudah Kita Pelajari?#

Pada artikel ini, kita berhasil membuat HTTP server menggunakan JavaScript tanpa framework.

Kita sudah mempraktikkan:

• Menjalankan JavaScript menggunakan Node.js.
• Menggunakan modul bawaan node:http.
• Membuat server dengan http.createServer().
• Mengenal objek req dan res.
• Menjalankan server menggunakan listen().
• Membuat routing sederhana.
• Mengirim response teks dan JSON.
• Menggunakan status code 200, 404, dan 500.
• Membaca pathname menggunakan URL.
• Menguji endpoint melalui browser dan curl.

Ini merupakan fondasi penting untuk mempelajari backend.

Kita sekarang sudah memahami bahwa API bukan sekadar alamat URL.

Di balik sebuah endpoint, terdapat program yang menerima request, menentukan tindakan, lalu mengirim response.

22. Penutup#

Selamat, Gabuters!

Kita sudah membuat HTTP server pertama menggunakan JavaScript dan Node.js native.

Tanpa Express.

Tanpa framework.

Tanpa dependency tambahan.

Walaupun masih sederhana, server kita sudah dapat menerima request dan mengembalikan JSON melalui beberapa endpoint.

Namun, ada satu hal yang belum kita lakukan.

Sejauh ini, semua endpoint hanya mengambil data menggunakan method GET.

Bagaimana jika kita ingin menambahkan artikel baru?

Bagaimana cara membaca body JSON dari request POST?

Bagaimana cara memperbarui atau menghapus data?

Pada artikel berikutnya, kita akan membuat REST API sederhana menggunakan JavaScript murni.

Kita akan mempraktikkan operasi CRUD menggunakan GET, POST, PUT, dan DELETE dengan penyimpanan sementara di memori.

Dengan begitu, kita mulai membangun backend yang dapat mengelola data, bukan hanya menampilkannya.

Sampai jumpa di artikel berikutnya, Gabuters!