Cara Membuat Website dengan Node.js: Panduan Lengkap untuk Pemula 2026

Mengapa Belajar Cara Membuat Website dengan Node.js?

Cara membuat website dengan Node.js adalah salah satu skill paling dicari oleh developer modern di Indonesia. Node.js adalah runtime JavaScript berbasis V8 engine milik Google yang memungkinkan Anda menjalankan kode JavaScript di sisi server - bukan hanya di browser. Dengan Node.js, satu bahasa pemrograman (JavaScript) bisa digunakan untuk membangun frontend maupun backend sekaligus, menjadikannya pilihan ideal bagi developer yang ingin produktif dan efisien.

Menurut survei Stack Overflow 2026, Node.js menempati posisi pertama sebagai runtime/framework web backend paling populer di dunia, digunakan oleh lebih dari 40% developer profesional. Perusahaan besar seperti Netflix, LinkedIn, Uber, PayPal, dan Tokopedia semuanya menggunakan Node.js sebagai fondasi infrastruktur backend mereka.

Dalam panduan ini, Anda akan belajar cara membuat website dengan Node.js mulai dari instalasi, membuat server HTTP pertama, menggunakan Express.js, menghubungkan database, hingga deploy ke hosting. Panduan ini dirancang untuk pemula yang baru pertama kali mencoba Node.js, namun tetap relevan bagi yang ingin memperdalam pemahaman.

Prasyarat Sebelum Belajar Node.js

Sebelum memulai, pastikan Anda sudah memiliki pemahaman dasar tentang:

• JavaScript dasar - variabel, fungsi, array, objek, callback, dan Promise
• JavaScript ES6+ - arrow function, destructuring, template literal, async/await, dan module (import/export)
• HTML dan CSS dasar - untuk memahami output yang dihasilkan server
• Penggunaan terminal/command prompt - Node.js banyak dikontrol via baris perintah

Jika Anda belum familiar dengan JavaScript modern, luangkan 2–3 minggu mempelajarinya terlebih dahulu. Fondasi JavaScript yang kuat akan membuat belajar Node.js terasa jauh lebih mudah dan intuitif.

Langkah 1: Instalasi Node.js di Komputer Anda

Langkah pertama dalam cara membuat website dengan Node.js adalah menginstal Node.js di mesin development Anda. Ada dua cara yang direkomendasikan:

Opsi A: Download Langsung dari nodejs.org (Termudah)

Kunjungi nodejs.org dan unduh versi LTS (Long Term Support) - per 2026, ini adalah Node.js 22.x. LTS adalah versi yang mendapat dukungan keamanan jangka panjang dan paling stabil untuk production. Jalankan installer, ikuti wizard, dan Node.js plus npm (Node Package Manager) akan terinstal otomatis.

Verifikasi instalasi berhasil dengan membuka terminal dan menjalankan:

node --version
# Output: v22.x.x

npm --version
# Output: 10.x.x

Opsi B: Menggunakan NVM (Direkomendasikan untuk Developer)

NVM (Node Version Manager) memungkinkan Anda mengelola dan beralih antar versi Node.js dengan mudah. Sangat berguna jika Anda mengerjakan beberapa proyek dengan versi Node.js yang berbeda.

# Install NVM (Linux/macOS)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# Reload shell
source ~/.bashrc

# Install dan gunakan Node.js LTS
nvm install --lts
nvm use --lts

Langkah 2: Memahami npm dan Struktur Proyek Node.js

Setiap proyek Node.js dikelola melalui file package.json yang menyimpan metadata proyek, dependensi, dan script perintah. Buat folder proyek baru dan inisialisasi:

mkdir website-nodejs-pertama
cd website-nodejs-pertama
npm init -y

Flag -y menjawab semua pertanyaan dengan nilai default secara otomatis. File package.json yang dihasilkan akan terlihat seperti ini:

{
  "name": "website-nodejs-pertama",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Struktur Folder Proyek Node.js yang Baik

Untuk proyek website Node.js skala kecil hingga menengah, gunakan struktur folder berikut:

website-nodejs-pertama/
├── src/
│   ├── controllers/     ← logic bisnis dan handler request
│   ├── routes/          ← definisi endpoint URL
│   ├── models/          ← definisi schema database
│   ├── middleware/      ← middleware kustom (auth, logging, dll)
│   ├── views/           ← template HTML (jika menggunakan template engine)
│   └── utils/           ← helper function yang dapat digunakan ulang
├── public/              ← file statis: CSS, JS frontend, gambar
├── .env                 ← variabel lingkungan (jangan di-commit ke Git!)
├── .env.example         ← contoh variabel lingkungan
├── .gitignore
├── package.json
└── index.js             ← entry point aplikasi

Langkah 3: Membuat HTTP Server Pertama dengan Node.js Native

Sebelum masuk ke framework, penting untuk memahami cara Node.js membuat server HTTP secara native menggunakan modul bawaan http. Buat file index.js:

// index.js - Server HTTP paling sederhana dengan Node.js
const http = require('http');

const PORT = 3000;

const server = http.createServer((req, res) => {
  // Set status code dan header response
  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });

  // Kirim response berdasarkan URL yang diminta
  if (req.url === '/') {
    res.end('<h1>Selamat Datang di Website Node.js Pertama Saya!</h1>');
  } else if (req.url === '/tentang') {
    res.end('<h1>Tentang Kami</h1><p>Website ini dibangun dengan Node.js.</p>');
  } else {
    res.writeHead(404);
    res.end('<h1>404 - Halaman Tidak Ditemukan</h1>');
  }
});

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

Jalankan dengan perintah node index.js dan buka browser ke http://localhost:3000. Anda sudah berhasil membuat web server pertama dengan Node.js!

Namun, membuat routing manual seperti di atas menjadi sangat rumit untuk proyek besar. Di sinilah Express.js hadir sebagai solusi.

Langkah 4: Menggunakan Express.js - Framework Web untuk Node.js

Express.js adalah framework web minimalis dan fleksibel untuk Node.js yang sangat populer. Express menyederhanakan pembuatan route, middleware, dan penanganan request/response HTTP.

Install Express.js

npm install express

Membuat Aplikasi Express Pertama

// index.js - Aplikasi Express.js dasar
const express = require('express');
const path = require('path');

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware bawaan Express
app.use(express.json());           // parsing request body JSON
app.use(express.urlencoded({ extended: true })); // parsing form data
app.use(express.static('public')); // serve file statis dari folder public/

// Route: Halaman Beranda
app.get('/', (req, res) => {
  res.send(`
    <!DOCTYPE html>
    <html lang="id">
    <head>
      <meta charset="UTF-8">
      <title>Website Node.js</title>
    </head>
    <body>
      <h1>Selamat Datang!</h1>
      <nav>
        <a href="/">Beranda</a> |
        <a href="/tentang">Tentang</a> |
        <a href="/kontak">Kontak</a>
      </nav>
      <p>Website ini dibangun dengan Node.js dan Express.js</p>
    </body>
    </html>
  `);
});

// Route: Halaman Tentang
app.get('/tentang', (req, res) => {
  res.send('<h1>Tentang Kami</h1><p>Kami adalah tim developer Indonesia.</p>');
});

// Route: API endpoint sederhana
app.get('/api/produk', (req, res) => {
  const produk = [
    { id: 1, nama: 'Web Hosting', harga: 15000 },
    { id: 2, nama: 'VPS', harga: 75000 },
    { id: 3, nama: 'Domain .com', harga: 150000 },
  ];
  res.json({ success: true, data: produk });
});

// Error handler 404
app.use((req, res) => {
  res.status(404).send('<h1>404 - Halaman Tidak Ditemukan</h1>');
});

// Jalankan server
app.listen(PORT, () => {
  console.log(`Server Express berjalan di http://localhost:${PORT}`);
});

Langkah 5: Menggunakan Template Engine (EJS)

Mengirim string HTML langsung dari kode JavaScript seperti di atas tidak praktis untuk halaman yang kompleks. Template engine memisahkan logika dan presentasi. EJS (Embedded JavaScript) adalah template engine paling populer untuk Node.js karena sintaksnya mirip HTML biasa.

npm install ejs

Konfigurasi Express untuk menggunakan EJS:

// Di index.js, tambahkan:
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'src/views'));

// Render template EJS
app.get('/', (req, res) => {
  res.render('index', {
    judul: 'Beranda',
    namaWebsite: 'Website Node.js Saya',
    daftarProduk: [
      { nama: 'Web Hosting', harga: 'Rp 15.000/bln' },
      { nama: 'VPS', harga: 'Rp 75.000/bln' },
    ]
  });
});

Buat file src/views/index.ejs:

<!-- src/views/index.ejs -->
<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8">
  <title><%= judul %> - <%= namaWebsite %></title>
</head>
<body>
  <h1>Selamat Datang di <%= namaWebsite %>!</h1>
  <h2>Daftar Produk Kami:</h2>
  <ul>
    <% daftarProduk.forEach(function(produk) { %>
      <li><strong><%= produk.nama %></strong> - <%= produk.harga %></li>
    <% }); %>
  </ul>
</body>
</html>

Langkah 6: Mengorganisasi Route dengan Router

Untuk proyek yang lebih besar, pisahkan route ke file terpisah menggunakan express.Router():

// src/routes/produkRoutes.js
const express = require('express');
const router = express.Router();

// GET semua produk
router.get('/', (req, res) => {
  res.json({ produk: [] });
});

// GET produk berdasarkan ID
router.get('/:id', (req, res) => {
  const { id } = req.params;
  res.json({ id, nama: 'Produk contoh' });
});

// POST tambah produk baru
router.post('/', (req, res) => {
  const { nama, harga } = req.body;
  res.status(201).json({ pesan: 'Produk berhasil ditambahkan', nama, harga });
});

module.exports = router;

Daftarkan router di index.js:

const produkRoutes = require('./src/routes/produkRoutes');
app.use('/api/produk', produkRoutes);
// Sekarang endpoint tersedia di: GET /api/produk, GET /api/produk/:id, POST /api/produk

Langkah 7: Koneksi Database dengan MongoDB (Mongoose)

Node.js bekerja sangat baik dengan MongoDB, database NoSQL yang menyimpan data dalam format JSON-like. Mongoose adalah library ODM (Object Document Mapper) yang memudahkan interaksi dengan MongoDB dari Node.js.

npm install mongoose dotenv

Buat file .env di root proyek:

PORT=3000
MONGODB_URI=mongodb://localhost:27017/website-nodejs
NODE_ENV=development

Koneksi ke MongoDB dan definisi model:

// src/models/Produk.js
const mongoose = require('mongoose');

const produkSchema = new mongoose.Schema({
  nama: {
    type: String,
    required: [true, 'Nama produk wajib diisi'],
    trim: true,
  },
  harga: {
    type: Number,
    required: [true, 'Harga wajib diisi'],
    min: 0,
  },
  deskripsi: {
    type: String,
    default: '',
  },
  aktif: {
    type: Boolean,
    default: true,
  },
  createdAt: {
    type: Date,
    default: Date.now,
  },
});

module.exports = mongoose.model('Produk', produkSchema);

// Di index.js, load dotenv dan koneksi Mongoose:
require('dotenv').config();
const mongoose = require('mongoose');

mongoose.connect(process.env.MONGODB_URI)
  .then(() => console.log('Terhubung ke MongoDB!'))
  .catch(err => console.error('Gagal koneksi MongoDB:', err));

Langkah 8: Middleware - Lapisan Pengolah Request

Middleware adalah fungsi yang dieksekusi sebelum request sampai ke handler route. Middleware dapat memodifikasi request/response, melakukan validasi, autentikasi, logging, dan banyak lagi.

Middleware Logging Sederhana

// src/middleware/logger.js
const logger = (req, res, next) => {
  const waktu = new Date().toISOString();
  console.log(`[${waktu}] ${req.method} ${req.url}`);
  next(); // Penting! Panggil next() agar request dilanjutkan ke handler berikutnya
};

module.exports = logger;

Middleware Autentikasi Sederhana

// src/middleware/auth.js
const authMiddleware = (req, res, next) => {
  const apiKey = req.headers['x-api-key'];

  if (!apiKey || apiKey !== process.env.API_KEY) {
    return res.status(401).json({
      success: false,
      pesan: 'Akses tidak diizinkan. API key tidak valid.'
    });
  }

  next();
};

module.exports = authMiddleware;

// Gunakan middleware di index.js atau route tertentu:
const logger = require('./src/middleware/logger');
const authMiddleware = require('./src/middleware/auth');

app.use(logger); // Berlaku untuk semua route

// Hanya untuk route API yang butuh autentikasi:
app.use('/api/admin', authMiddleware, adminRoutes);

Langkah 9: Menangani Error dengan Baik

Error handling yang baik adalah ciri aplikasi Node.js yang profesional. Buat error handler terpusat:

// src/middleware/errorHandler.js
const errorHandler = (err, req, res, next) => {
  console.error('Error:', err.stack);

  const statusCode = err.statusCode || 500;
  const pesan = err.message || 'Terjadi kesalahan pada server';

  res.status(statusCode).json({
    success: false,
    pesan,
    // Tampilkan stack trace hanya di development
    ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
  });
};

module.exports = errorHandler;

// Di index.js, daftarkan SETELAH semua route (penting!):
const errorHandler = require('./src/middleware/errorHandler');
app.use(errorHandler);

Di dalam route, lempar error dengan next(error):

app.get('/api/produk/:id', async (req, res, next) => {
  try {
    const produk = await Produk.findById(req.params.id);
    if (!produk) {
      const error = new Error('Produk tidak ditemukan');
      error.statusCode = 404;
      return next(error);
    }
    res.json({ success: true, data: produk });
  } catch (err) {
    next(err); // Teruskan ke error handler
  }
});

Langkah 10: Install Nodemon untuk Development yang Nyaman

Selama development, Anda ingin server otomatis restart setiap kali kode berubah. Gunakan nodemon:

npm install -D nodemon

Tambahkan script di package.json:

{
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "dev:debug": "nodemon --inspect index.js"
  }
}

Sekarang jalankan npm run dev - server akan otomatis restart setiap Anda menyimpan perubahan kode. Sangat menghemat waktu development!

Langkah 11: Keamanan Dasar Aplikasi Node.js

Sebelum deploy ke production, terapkan beberapa lapisan keamanan dasar:

Install Package Keamanan

npm install helmet cors express-rate-limit

const helmet = require('helmet');
const cors = require('cors');
const rateLimit = require('express-rate-limit');

// Helmet: set HTTP headers keamanan
app.use(helmet());

// CORS: izinkan request dari domain tertentu saja
app.use(cors({
  origin: process.env.ALLOWED_ORIGIN || 'http://localhost:3000',
  credentials: true,
}));

// Rate limiting: batasi request ke 100 per 15 menit per IP
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 menit
  max: 100,
  message: { pesan: 'Terlalu banyak request, coba lagi nanti.' }
});
app.use('/api', limiter);

Langkah 12: Persiapan Deploy ke Production

Sebelum deploy, pastikan beberapa hal berikut sudah dilakukan:

• Set NODE_ENV=production di server production
• Jangan pernah menyertakan file .env di repositori Git
• Pastikan semua dependensi sudah terinstal dengan npm install --production
• Gunakan PM2 sebagai process manager untuk menjaga aplikasi tetap berjalan
• Konfigurasikan Nginx sebagai reverse proxy di depan aplikasi Node.js Anda

Untuk panduan deploy lengkap ke VPS dengan PM2 dan Nginx, baca artikel Cara Deploy Node.js ke VPS: Panduan Setup PM2 dan Nginx.

FAQ: Cara Membuat Website dengan Node.js

Kesimpulan

Belajar cara membuat website dengan Node.js membuka pintu ke dunia pengembangan web modern yang penuh kemungkinan. Dari HTTP server native hingga Express.js yang powerful, dari template engine EJS hingga REST API yang terhubung ke database - setiap konsep yang Anda kuasai membangun fondasi untuk menjadi developer Node.js yang profesional.

Kunci keberhasilan adalah membangun proyek nyata, sekecil apapun. Mulailah dengan API sederhana, tambahkan fitur satu per satu, dan jangan takut membaca dokumentasi resmi di nodejs.org dan expressjs.com. Komunitas Node.js Indonesia juga sangat aktif di berbagai forum dan grup online.

Ketika website Node.js Anda siap di-deploy, pastikan memilih hosting yang tepat - baik shared hosting dengan Node.js Selector untuk pemula, atau VPS untuk kontrol dan performa penuh. Baca panduan lanjutan kami tentang cara deploy Node.js ke VPS dan rekomendasi VPS terbaik untuk Node.js di Indonesia.