Home > Blog > Cara Menghubungkan Node.js dengan Database (MongoDB/MySQL)

Cara Menghubungkan Node.js dengan Database (MongoDB/MySQL)

21 Feb 2025 | dibaca 22 kali

Node.js telah menjadi salah satu platform paling populer untuk membangun aplikasi backend modern. Salah satu alasan utamanya adalah ekosistem yang besar, dukungan komunitas yang kuat, dan kemudahan untuk menghubungkan Node.js dengan berbagai macam database, termasuk MongoDB dan MySQL. Dalam artikel ini, kita akan membahas cara menghubungkan Node.js dengan kedua tipe database tersebut—mulai dari instalasi, konfigurasi, hingga contoh kode dasar yang siap digunakan.

1. Pengenalan Singkat Node.js

Node.js adalah runtime JavaScript yang berjalan di sisi server. Artinya, kita bisa menjalankan JavaScript di luar browser. Biasanya, Node.js sering dipakai untuk membangun API (Application Programming Interface), real-time applications seperti chat, serta berbagai sistem yang membutuhkan performa tinggi.

Untuk mulai menggunakan Node.js, kita perlu menginstalnya terlebih dahulu dari situs resminya (https://nodejs.org). Setelah terinstal, kita bisa menggunakan perintah node -v di terminal atau command prompt untuk memastikan versi Node.js yang terpasang.

Selain Node.js, kita biasanya juga menggunakan npm (Node Package Manager) atau yarn untuk mengelola paket-paket yang dibutuhkan. Misalnya, untuk menginstal suatu library, kita bisa jalankan perintah:

npm install

atau

yarn add

Dalam konteks database, kita akan membutuhkan paket-paket khusus yang menghubungkan Node.js dengan database pilihan kita. Misalnya, untuk MongoDB kita bisa menggunakan Mongoose atau driver resmi MongoDB, sedangkan untuk MySQL kita bisa menggunakan mysql, mysql2, atau ORM seperti Sequelize.

2. Persiapan Umum Sebelum Menghubungkan Ke Database

  1. Folder Proyek
    Buatlah folder untuk proyek Node.js kita. Misalnya:

    mkdir project-database
cd project-database

    Di dalam folder ini kita akan menempatkan semua file dan konfigurasi.

  2. Inisialisasi Proyek
    Selanjutnya, inisialisasi proyek dengan npm init atau yarn init. Biasanya kita akan diminta mengisi beberapa informasi seperti nama proyek, versi, deskripsi, dan lain-lain. Proses ini akan menghasilkan sebuah file package.json yang berisi detail proyek berikut daftar dependencies.

  3. File Utama (entry point)
    Secara default, file utama proyek Node.js sering dinamai index.js atau app.js. Kita bisa buat file baru, misalnya app.js, yang nanti akan menjadi pintu masuk ke aplikasi kita.

  4. Instalasi Dependensi

    • Untuk MongoDB dengan Mongoose, kita bisa jalankan: 
      npm install mongoose
      atau 
      yarn add mongoose
    • Untuk MongoDB dengan driver resmi (opsional, jika tidak pakai Mongoose): 
      npm install mongodb
    • Untuk MySQL, ada beberapa pilihan, tapi yang populer adalah: 
      npm install mysql2
    • Jika ingin menggunakan Sequelize (ORM untuk SQL), maka: 
      npm install sequelize mysql2
      (Sequelize itu sendiri adalah ORM, tapi untuk berkomunikasi dengan MySQL, kita juga butuh driver mysql2.)

3. Menghubungkan Node.js dengan MongoDB

3.1. Sekilas Tentang MongoDB

MongoDB adalah database NoSQL berbasis dokumen yang menggunakan format JSON (BSON di bawah 'kap mesin'). Ia populer karena fleksibilitas struktur datanya. Jika kamu sering bekerja dengan data semi-terstruktur, MongoDB bisa jadi pilihan tepat.

Untuk menggunakan MongoDB, kamu bisa memasangnya di komputer sendiri (melalui MongoDB Community Edition) atau memanfaatkan layanan hosting seperti MongoDB Atlas, yang memungkinkan kita punya database di cloud tanpa harus repot mengelola server database sendiri.

3.2. Contoh Koneksi MongoDB Menggunakan Mongoose

3.2.1. Instalasi MongoDB (Opsional Jika Pakai Cloud)

Jika menggunakan MongoDB Atlas (cloud):

3.2.2. Koneksi Dasar Dengan Mongoose

Mongoose adalah library ODM (Object Data Modeling) yang membantu kita mengelola skema (schema) dan berinteraksi dengan MongoDB secara lebih mudah. Selain menghandle koneksi, Mongoose juga membantu membuat model data.

  1. Pastikan kita sudah berada di folder proyek.
  2. Instal Mongoose: 
    npm install mongoose
  3. Di file app.js, kita tuliskan: 
    const mongoose = require('mongoose');

// URL koneksi ke MongoDB (bisa localhost atau MongoDB Atlas)
const dbURL = 'mongodb://127.0.0.1:27017/mydatabase'; 
// atau contoh untuk Atlas:
// const dbURL = 'mongodb+srv://username:password@cluster0.abcde.mongodb.net/mydatabase';

// Opsional: Tambahkan opsi konfigurasi
const options = {
  useNewUrlParser: true,
  useUnifiedTopology: true,
};

mongoose.connect(dbURL, options)
  .then(() => {
    console.log('Terhubung ke MongoDB dengan sukses!');
  })
  .catch(err => {
    console.error('Gagal terhubung ke MongoDB:', err);
  });

// Contoh mendefinisikan schema dan model
const userSchema = new mongoose.Schema({
  nama: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  umur: Number
});

const User = mongoose.model('User', userSchema);

// Menyimpan data contoh
const userBaru = new User({
  nama: 'Budi',
  email: 'budi@example.com',
  umur: 25
});

userBaru.save()
  .then(doc => {
    console.log('Data user berhasil disimpan:', doc);
  })
  .catch(err => {
    console.error('Gagal menyimpan data user:', err);
  });

Penjelasan kode di atas:

Sederhana, bukan? Begitu dasar cara menghubungkan Node.js dengan MongoDB menggunakan Mongoose.

3.3. Menjalankan dan Menguji

Untuk menjalankan aplikasi, cukup ketik di terminal:

node app.js

Jika semua konfigurasi benar, akan muncul log “Terhubung ke MongoDB dengan sukses!” dan “Data user berhasil disimpan: ...” di terminal, lalu data akan masuk ke koleksi users di database MongoDB-mu.

Jika menggunakan Atlas, pastikan username, password, dan nama database yang kamu cantumkan dalam string koneksi sudah benar. Kadang, kita juga perlu mengizinkan IP address kita di bagian Network Access di dashboard MongoDB Atlas.

3.4. Tips dan Praktik Terbaik

4. Menghubungkan Node.js dengan MySQL

4.1. Sekilas Tentang MySQL

MySQL adalah salah satu relational database management system (RDBMS) paling populer di dunia. Ia menggunakan struktur tabel dengan baris dan kolom, mendukung bahasa SQL (Structured Query Language). Cocok untuk data yang relatif terstruktur dan memiliki relasi yang jelas.

Untuk bisa menggunakan MySQL, kita perlu menginstal MySQL Server (community edition) di komputer kita, atau kita dapat memakai layanan cloud seperti Amazon RDS, Google Cloud SQL, Azure Database for MySQL, dan sebagainya.

4.2. Persiapan MySQL

  1. Instalasi MySQL Server (Jika Lokal)
    Unduh installer MySQL Community Edition dari https://dev.mysql.com/downloads/. Setelah diinstal, buat user dan password. Default user biasanya root.

  2. Buat Database
    Misalnya, kita buat database bernama test_db. Kita bisa melakukannya lewat MySQL CLI atau tool seperti phpMyAdmin, MySQL Workbench, dan sejenisnya:

    CREATE DATABASE test_db;
USE test_db;

    Selanjutnya, kita bisa membuat tabel, contohnya:

    CREATE TABLE users (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(50) NOT NULL,
  email VARCHAR(50) NOT NULL,
  age INT
);

  3. Siapkan Koneksi
    Pastikan kita tahu host (default: localhost), port (default: 3306), username (misal root), password (misal 1234), dan nama database (test_db).

4.3. Koneksi Dasar Menggunakan mysql2

4.3.1. Instalasi Paket

Di folder proyek Node.js kita, jalankan:

npm install mysql2

4.3.2. Kode Contoh

Buat atau edit app.js untuk menambahkan kode berikut:

const mysql = require('mysql2');

// Konfigurasi koneksi
const connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',        // ganti sesuai usermu
  password: '1234',    // ganti sesuai passwordmu
  database: 'test_db', // ganti sesuai nama database
});

// Membuat koneksi
connection.connect((err) => {
  if (err) {
    console.error('Gagal terhubung ke MySQL:', err);
    return;
  }
  console.log('Terhubung ke MySQL dengan sukses!');
});

// Contoh insert data
const sqlInsert = 'INSERT INTO users (name, email, age) VALUES (?, ?, ?)';
const values = ['Andi', 'andi@example.com', 30];

connection.query(sqlInsert, values, (err, results) => {
  if (err) {
    console.error('Gagal menyimpan data:', err);
    return;
  }
  console.log('Data berhasil disimpan, ID:', results.insertId);
});

// Contoh select data
const sqlSelect = 'SELECT * FROM users';
connection.query(sqlSelect, (err, rows) => {
  if (err) {
    console.error('Gagal mengambil data:', err);
    return;
  }
  console.log('Data users:', rows);
});

// Menutup koneksi (opsional, tergantung skenario)
connection.end((err) => {
  if (err) {
    console.error('Error saat menutup koneksi:', err);
    return;
  }
  console.log('Koneksi MySQL ditutup.');
});

Penjelasan singkat:

Jika kita menjalankan node app.js, seharusnya muncul log:

Terhubung ke MySQL dengan sukses!
Data berhasil disimpan, ID: 1
Data users: [
  {
    id: 1,
    name: 'Andi',
    email: 'andi@example.com',
    age: 30
  }
]
Koneksi MySQL ditutup.

Database pun akan berisi satu baris data baru di tabel users.

4.4. Menggunakan Pool Koneksi

Dalam produksi, lebih disarankan untuk menggunakan connection pool daripada single connection. Pool memungkinkan kita memiliki sejumlah koneksi siap pakai yang dapat digunakan secara bersamaan, sehingga performa aplikasi lebih baik.

Contoh implementasi connection pool:

const mysql = require('mysql2');

const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: '1234',
  database: 'test_db',
  connectionLimit: 10 // jumlah koneksi maksimum
});

pool.query('SELECT * FROM users', (err, rows) => {
  if (err) {
    return console.error('Gagal mengambil data:', err);
  }
  console.log('Data users dari pool:', rows);
});

Dengan pool, kita tidak perlu lagi memanggil connect() dan end(). Setiap kali kita butuh menjalankan query, pool akan mengelola koneksi di belakang layar.

4.5. ORM: Sequelize

Untuk aplikasi yang lebih kompleks, kita mungkin akan lebih nyaman menggunakan ORM seperti Sequelize. ORM membantu kita menuliskan kode manipulasi data (CRUD) tanpa harus menulis query SQL secara langsung setiap saat.

4.5.1. Instalasi

npm install sequelize mysql2

4.5.2. Kode Contoh

Berikut contoh singkat penggunaan Sequelize untuk MySQL:

const { Sequelize, DataTypes } = require('sequelize');

// Membuat instance Sequelize
const sequelize = new Sequelize('test_db', 'root', '1234', {
  host: 'localhost',
  dialect: 'mysql'
});

// Definisikan model User
const User = sequelize.define('User', {
  name: {
    type: DataTypes.STRING,
    allowNull: false
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false
  },
  age: {
    type: DataTypes.INTEGER
  }
}, {
  tableName: 'users' // pastikan sama dengan nama tabel di database
});

// Sinkronisasi model dengan database
sequelize.sync()
  .then(() => {
    console.log('Database & tables created!');

    // Contoh menambahkan data
    return User.create({
      name: 'Sinta',
      email: 'sinta@example.com',
      age: 28
    });
  })
  .then((newUser) => {
    console.log('User baru:', newUser.toJSON());

    // Contoh mengambil semua data
    return User.findAll();
  })
  .then((allUsers) => {
    console.log('Semua user:', allUsers.map(u => u.toJSON()));
  })
  .catch(err => {
    console.error('Terjadi kesalahan:', err);
  });

Dalam potongan kode di atas:

ORM semacam ini memudahkan manajemen database ketika aplikasi menjadi lebih besar. Kita pun bisa berpindah ke database lain yang didukung Sequelize (misal PostgreSQL) hanya dengan mengubah konfigurasi dialect dan driver yang diperlukan.

5. Mengelola Variabel Lingkungan (Environment Variables)

Saat menghubungkan Node.js dengan database, kita seringkali perlu menyimpan informasi sensitif seperti username, password, atau string koneksi. Jangan pernah mendorong (push) data ini ke repositori publik. Solusinya adalah menggunakan file .env.

  1. Instalasi dotenv 
    npm install dotenv
  2. Buat file .env
    Di root proyek, buat file .env: 
    DB_HOST=localhost
DB_USER=root
DB_PASS=1234
DB_NAME=test_db
    Jika MongoDB: 
    MONGO_URI=mongodb+srv://username:password@cluster0.abcde.mongodb.net/mydatabase
  3. Impor dotenv di app.js (atau di file utama) 
    require('dotenv').config();
  4. Akses variabel environment 
    const mysql = require('mysql2');

const connection = mysql.createConnection({
  host: process.env.DB_HOST,
  user: process.env.DB_USER,
  password: process.env.DB_PASS,
  database: process.env.DB_NAME,
});
  5. .gitignore
    Pastikan file .env dicantumkan dalam .gitignore agar tidak ter-upload ke repository publik.

Dengan cara ini, kita bisa menjaga keamanan kredensial database kita.

6. Error Handling dan Logging

6.1. Error Handling

Kedua jenis database tersebut (MongoDB dan MySQL) tentunya bisa mengalami error. Dalam Node.js, penanganan error bisa dilakukan dengan:

Contoh pendekatan async-await:

const getAllUsers = async () => {
  try {
    const [rows] = await pool.query('SELECT * FROM users');
    return rows;
  } catch (err) {
    console.error('Error saat mengambil data:', err);
    throw err;
  }
};

Dengan async-await, kode kita terlihat lebih bersih dan mudah diikuti.

6.2. Logging

Untuk logging, selain console.log(), kita bisa menggunakan library seperti winston atau morgan (biasanya untuk HTTP request logging). Dengan logging yang rapi, kita bisa memantau aktivitas dan error di aplikasi dengan lebih efektif.

7. Struktur Proyek yang Lebih Baik

Dalam proyek real-world, kita biasanya tidak menulis semua kode dalam satu file app.js saja. Kita akan membaginya menjadi folder dan file yang terorganisir:

Contoh struktur direktori:

project-database/
  ├─ config/
  │   └─ db.js
  ├─ models/
  │   └─ userModel.js
  ├─ routes/
  │   └─ userRoutes.js
  ├─ controllers/
  │   └─ userController.js
  ├─ app.js
  ├─ package.json
  ├─ .env
  └─ .gitignore

Dalam db.js, kita hanya fokus pada konfigurasi dan koneksi ke database. Di userModel.js, kita definisikan schema atau model user. Di userController.js, kita tulis fungsi untuk CRUD user. Di userRoutes.js, kita definisikan endpoint HTTP seperti GET /users, POST /users, dsb. Lalu di app.js, kita memanggil route tersebut dan menyalakannya dengan server (misalnya Express).

8. Beberapa Pertimbangan Tambahan

  1. Keamanan

    • Gunakan enkripsi SSL/TLS jika database mendukungnya (sering kali default di cloud services).
    • Batasi IP yang bisa terhubung ke database (firewall atau pengaturan whitelisting).

  2. Optimasi Performansi

    • Untuk MongoDB, pastikan membuat index di field yang sering digunakan pada query.
    • Untuk MySQL, normalisasi database jika butuh integritas data yang kuat, atau lakukan indexing di kolom yang sering di-filter.
    • Gunakan connection pool untuk MySQL, dan re-use connection di MongoDB.

  3. Pemilihan Database

    • MongoDB cocok kalau struktur datamu dinamis, skema bisa berubah, dan kamu butuh fleksibilitas tinggi.
    • MySQL cocok kalau datamu sangat terstruktur, butuh integritas kuat (ACID), dan sering melakukan join antar-tabel.
    • Tidak jarang, aplikasi besar memadukan kedua jenis database sesuai kebutuhan masing-masing modul.

  4. Pencadangan (Backup)

    • Pastikan memiliki mekanisme backup database secara rutin, baik snapshot di MongoDB Atlas atau backup file .sql di MySQL.

  5. Migration

    • Di MySQL/SQL Database, perubahan skema tabel sering dikelola lewat migration tools atau ORM.
    • Di MongoDB, banyak tim yang mengatur perubahan schema “on-the-fly” atau memanfaatkan library khusus untuk migration.

  6. Monitoring

    • Gunakan tools seperti PM2 atau Forever untuk menjalankan aplikasi Node.js di server.
    • Monitor penggunaan resource database, catat query lambat, dan optimasi jika diperlukan.

9. Contoh Skenario Singkat REST API Sederhana

Banyak pengembang menggunakan Node.js untuk membuat REST API yang terhubung dengan database. Misalnya, kita membuat API CRUD untuk user. Gambaran singkat (menggunakan Express):

9.1. Instalasi Express

npm install express

9.2. File app.js

const express = require('express');
const mysql = require('mysql2');

const app = express();
app.use(express.json());

// Buat koneksi pool MySQL
const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: '1234',
  database: 'test_db',
  connectionLimit: 10
});

// Endpoint GET /users
app.get('/users', (req, res) => {
  pool.query('SELECT * FROM users', (err, rows) => {
    if (err) {
      return res.status(500).json({ error: err.message });
    }
    res.json(rows);
  });
});

// Endpoint POST /users
app.post('/users', (req, res) => {
  const { name, email, age } = req.body;
  const sqlInsert = 'INSERT INTO users (name, email, age) VALUES (?, ?, ?)';
  pool.query(sqlInsert, [name, email, age], (err, results) => {
    if (err) {
      return res.status(500).json({ error: err.message });
    }
    res.json({ id: results.insertId, name, email, age });
  });
});

// Jalankan server
app.listen(3000, () => {
  console.log('Server berjalan di port 3000');
});

Setelah itu, kita bisa uji menggunakan tool seperti Postman atau cURL:

Tentu saja, kita bisa melakukan hal serupa dengan MongoDB. Caranya mirip; bedanya kita akan menulis query Mongoose di route handler, misalnya User.find() untuk GET, User.create() untuk POST, dan seterusnya.


Baca Juga :