7 Konsep Teratas yang Perlu Diketahui Saat Menggunakan MongoDB untuk Pemula

MongoDB adalah database NoSQL yang menggunakan pendekatan fleksibel berbasis dokumen untuk menyimpan data dalam dokumen mirip JSON yang diorganisasikan ke dalam koleksi. Singkatnya, saat bekerja dengan MongoDB, data Anda disimpan dengan cara yang terlihat sangat mirip JSON. Ini membuatnya mudah dibaca, mudah dipetakan ke kode, dan dapat diskalakan. MongoDB bersifat modern dan mengikuti pendekatan yang berbeda dari database relasional. Database relasional menyimpan data menggunakan baris dalam tabel. Pendekatan ini memiliki keunggulan, tetapi salah satu tantangannya adalah membuat relasi menggunakan tabel tambahan. MongoDB menyelesaikan masalah ini dengan memperkenalkan pendekatan skema yang fleksibel di mana data disimpan dalam koleksi, bukan tabel. Artinya, data yang terkait dengan sebuah objek dapat disimpan bersama objek tersebut. Dalam tutorial ini, kita akan membahas tujuh konsep yang perlu diketahui pemula saat menggunakan MongoDB. Dengan demikian, mari kita mulai.

Memahami NoSQL dan Database Dokumen

Ketika kebanyakan orang memikirkan database, mereka membayangkan SQL yang menyimpan data menggunakan baris, tabel, dan relasi. Ini bagus untuk banyak aplikasi, terutama ketika data aplikasi terstruktur. Namun bisa terasa membatasi ketika data tidak pas dimasukkan ke dalam struktur tabel.

Di sinilah NoSQL hadir. NoSQL berarti "bukan hanya SQL." Ini mencakup keluarga database yang meninggalkan model tabel yang kaku untuk menawarkan lebih banyak fleksibilitas. Alih-alih memaksa semua data ke kolom yang telah ditentukan, Anda dapat menatanya dengan cara yang sesuai dengan cara aplikasi Anda sebenarnya bekerja.

MongoDB adalah database dokumen, salah satu jenis database NoSQL yang paling populer. Alih-alih baris dan tabel, data disimpan sebagai dokumen dalam koleksi. Setiap dokumen terlihat sangat mirip JSON, dengan pasangan kunci-nilai, array, bahkan objek bersarang. Ini membuatnya sangat mudah untuk merepresentasikan data dunia nyata. Contoh yang baik adalah profil pengguna dengan alamat dan preferensi dalam satu catatan, tanpa harus menyebarkannya ke beberapa tabel. Mari kita lihat seperti apa profil pengguna dengan alamat dan preferensi dalam satu catatan di MongoDB.

{
"_id": "u123",
"name": "Moses Anu",
"email": "moses@example.com",
"addresses": [
{ "type": "home", "city": "Abuja" },
{ "type": "work", "city": "Lagos" }
],
"preferences": {
"language": "English",
"theme": "dark"
}
}

Dasar-Dasar Arsitektur MongoDB

Untuk bekerja dengan MongoDB secara efektif, kita perlu memahami organisasi data dalam database MongoDB. Tidak seperti database SQL, di mana data distrukturkan dalam tabel dan baris, MongoDB menggunakan koleksi dan dokumen.

• Database: Anggap saja sebagai wadah untuk semuanya. Sama seperti Anda dapat memiliki beberapa database di MySQL, MongoDB juga memberi fleksibilitas untuk memiliki banyak database untuk proyek atau aplikasi yang berbeda.
• Koleksi: Di dalam setiap database, Anda memiliki koleksi. Anggap koleksi seperti tabel dengan skema yang sangat fleksibel. Ini karena tabel MongoDB tidak menerapkan skema yang kaku. Anda dapat memasukkan dokumen dengan field yang berbeda ke dalam koleksi yang sama.
• Dokumen: Di sinilah keajaiban sesungguhnya terjadi. Dokumen adalah objek mirip JSON (sebenarnya, BSON di balik layar) yang menyimpan data Anda. Dokumen dapat memiliki objek dan array bersarang, sehingga jauh lebih alami digunakan pada aplikasi modern. Kita akan membahas lebih lanjut tentang BSON di paragraf berikutnya.

Untuk lebih memahami arsitektur MongoDB, mari ambil contoh. Misalkan kita membangun aplikasi e-commerce sederhana menggunakan MongoDB. Data kita akan mengikuti struktur berikut.

• Memiliki sebuah database bernama shopDB.
• Di dalamnya, sebuah koleksi bernama products.
• Dan di dalam koleksi tersebut, dokumen yang merepresentasikan setiap produk dengan detail seperti nama, harga, dan kategori.

Skema yang fleksibel

Untuk lebih memahami konsep skema yang fleksibel, dari contoh di atas, ketahuilah bahwa sebuah produk bisa memiliki field diskon, sementara produk lain tidak. MongoDB tidak memaksa setiap produk memiliki field yang persis sama. Fleksibilitas ini menjadi salah satu alasan utama pengembang menyukai MongoDB, terutama saat membangun aplikasi yang berkembang cepat.

BSON dan Tipe Data

Jika Anda pernah bekerja dengan JSON, MongoDB akan terasa sangat alami. Faktanya, MongoDB tidak benar-benar menyimpan data Anda sebagai JSON biasa. MongoDB menggunakan sesuatu yang disebut BSON. BSON adalah singkatan dari Binary JSON.

Apa itu BSON, dan mengapa MongoDB menggunakannya?

BSON ibarat sepupu JSON yang lebih cerdas dan efisien. Ia mempertahankan struktur kunci-nilai yang mudah dibaca dan digemari pengembang, tetapi menambahkan beberapa keunggulan:

• Mendukung lebih banyak tipe data daripada JSON (seperti tanggal, desimal, dan biner mentah).
• Dioptimalkan untuk encoding/decoding yang cepat, yang membuat kueri MongoDB berjalan lebih cepat.
• Menyimpan semuanya dalam format biner yang ringkas, sehingga lebih efisien untuk jumlah data yang besar.

Intinya, BSON memberi MongoDB fleksibilitas JSON ditambah kinerja dan ketelitian yang dibutuhkan database.

Tipe data BSON yang umum

MongoDB mendukung berbagai tipe data, tetapi berikut yang paling umum beserta contohnya:

• String :"name": "Alice"
• Number : "age": 28
• Boolean : "isActive": true
• Date : "createdAt": ISODate("2025-08-18T10:00:00Z")
• Array : "skills": ["MongoDB", "Node.js", "React"]
• Dokumen tertanam. Objek bersarang di dalam dokumen:

"address": { 
  "city": "Lagos", 
  "country": "Nigeria" 
}

• ObjectId: tipe ID khusus yang digunakan MongoDB untuk ID dokumen unik. ObjectId("64f5c9e8a5f76b1d2c3a4567")

Mari kita lihat contoh dokumen profil pengguna dalam format BSON yang disimpan di MongoDB:

{
  "_id": ObjectId("64f5c9e8a5f76b1d2c3a4567"),
  "name": "Moses",
  "age": 30,
  "isActive": true,
  "skills": ["Laravel", "MongoDB", "Vue"],
  "address": {
    "city": "Abuja",
    "country": "Nigeria"
  },
  "createdAt": ISODate("2025-08-18T10:00:00Z")
}

Beberapa hal yang perlu kita perhatikan:

• Field _id dibuat otomatis sebagai ObjectId jika Anda tidak mengaturnya sendiri.
• Tanggal disimpan sebagai ISODate, bukan sekadar string biasa.
• Dokumen address yang bersarang dan array skills menunjukkan fleksibilitas MongoDB dibandingkan baris SQL yang datar.

Prinsip Desain Skema

MongoDB memungkinkan Anda mengembangkan model data seiring pertumbuhan aplikasi karena memiliki skema yang fleksibel. Namun, tanpa desain skema yang tepat, skema fleksibel MongoDB bisa cepat menjadi berantakan. Anda tidak boleh membuang struktur begitu saja hanya karena MongoDB menyediakan skema yang fleksibel. Mari bahas beberapa prinsip desain skema saat bekerja dengan MongoDB.

Skema fleksibel vs. tanpa skema

MongoDB sering digambarkan sebagai tanpa skema, tetapi itu agak menyesatkan. Setiap dokumen sebenarnya memiliki skema—hanya saja tidak ditegakkan di tingkat database kecuali Anda memilih menambahkan aturan validasi.

Misalnya, dua dokumen dalam koleksi users yang sama secara teknis bisa terlihat sangat berbeda:

// Document 1
{ "name": "Alice", "email": "alice@example.com" }

// Document 2
{ "username": "Bob123", "age": 29 }

Fleksibilitas ini bisa sangat berguna saat prototyping cepat, tetapi di produksi, Anda biasanya menginginkan konsistensi. Di sinilah validasi JSON Schema berperan. Anda dapat menerapkan aturan tertentu agar tidak berakhir dengan data yang berantakan dan tidak andal.

Menyematkan vs. mereferensikan dokumen

Keputusan penting lainnya dalam desain skema MongoDB adalah cara memodelkan relasi. Mari kita lihat beberapa cara relasi dapat dimodelkan dalam dokumen MongoDB.

Menyematkan (menyusun data di dalam sebuah dokumen)

MongoDB mendukung penyematan dokumen di dalam koleksi. Pendekatan ini paling baik digunakan untuk data yang diakses bersama. Contohnya adalah postingan blog dengan komentarnya disimpan langsung di dalamnya. Berikut contoh penyematan data.

{
  "title": "Intro to MongoDB",
  "comments": [
    { "user": "Alice", "text": "Great post!" },
    { "user": "Bob", "text": "Very helpful." }
  ]
}

Data yang disimpan dengan cara ini memiliki kinerja lebih baik, dan membutuhkan lebih sedikit kueri untuk diambil atau diolah. Jika tidak ditata dengan benar, juga dapat menyebabkan dokumen menjadi terlalu gemuk.

Mereferensikan (menautkan antar dokumen)

Dalam situasi ketika ukuran data terkait menjadi besar atau sering digunakan kembali, disarankan untuk menautkan data antar dokumen. Ini dikenal sebagai referensi.

Contohnya adalah postingan blog dengan banyak komentar. Dalam situasi ini, kita dapat menyimpan hanya ID komentar, dan komentar sebenarnya berada di koleksi tersendiri. Kode di bawah ini adalah contoh pendekatan ini.

// Blog post
{ "title": "Intro to MongoDB", "commentIds": [ObjectId("..."), ObjectId("...")] }

// Separate comment document
{ "_id": ObjectId("..."), "user": "Alice", "text": "Great post!" }

Menata data kita seperti ini membuat dokumen tetap kecil, menghindari duplikasi, dan membuat kode mudah dirawat. Namun, ini memerlukan beberapa kueri (meskipun Anda dapat menggunakan join $lookup dalam agregasi).

Menghindari kesalahan umum desain skema

Terlalu banyak menyematkan: Karena MongoDB memiliki skema yang fleksibel, mudah tergoda untuk memasukkan semuanya ke dalam satu dokumen raksasa. Ini tidak disarankan dan dapat menyebabkan kinerja buruk. MongoDB menerapkan ukuran maksimum 16MB per dokumen. Ini untuk memastikan pengembang menata data ke dalam dokumen dengan benar.

Mengabaikan indeks: Jangan mengabaikan indeks saat bekerja dengan MongoDB. Jika kueri Anda tidak selaras dengan desain skema, Anda akan berakhir dengan pencarian yang lambat. Selalu rancang dengan pola akses dalam pikiran.

Memperlakukan MongoDB seperti SQL: Tidak apa-apa memecah data menjadi dokumen kecil. Namun, pahami bahwa MongoDB memiliki skema fleksibel, dan jangan memperlakukannya seperti database relasional. Jika Anda hanya menyalin skema relasional 1:1 ke MongoDB (banyak tabel/koleksi kecil yang ternormalisasi), Anda kehilangan keuntungan pemodelan dokumen.

Luangkan waktu untuk merencanakan skema Anda. Skema yang matang dapat sangat memengaruhi kinerja aplikasi Anda.

Validasi Data

MongoDB itu fleksibel. Ini dapat dengan mudah mengarah pada data yang tidak terstruktur dan tidak tertata jika tidak hati-hati. Di sinilah validasi data berperan.

Anggap validasi sebagai penetapan aturan dasar untuk koleksi Anda. Ini memastikan setiap dokumen yang dimasukkan atau diperbarui mengikuti aturan tertentu, seperti mewajibkan field email atau memastikan "age" selalu berupa angka.

Menggunakan validasi JSON Schema di MongoDB

MongoDB mendukung JSON Schema untuk validasi. JSON Schema adalah cara standar untuk mendeskripsikan bentuk dokumen Anda. Beberapa aturan yang dapat diterapkan meliputi:

• Field wajib.
• Tipe data (string, number, date, dll.).
• Rentang nilai atau pola string.

Validasi data dapat memberi kita yang terbaik dari kedua dunia saat bekerja dengan MongoDB. Skema fleksibel MongoDB ditambah pembatas membantu menjaga data tetap bersih.

Menerapkan aturan untuk menjaga data tetap bersih

Misalkan kita memiliki koleksi users. Kita ingin memastikan bahwa:

• Setiap pengguna memiliki nama (string).
• Setiap pengguna memiliki email (string, harus terlihat seperti email).
• Jika age ada, itu harus berupa angka lebih besar atau sama dengan 18.

Berikut cara kita dapat menerapkannya dengan validator JSON Schema:

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email"],
      properties: {
        name: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+\\..+$",
          description: "must be a valid email address"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          description: "must be an integer greater than or equal to 18"
        }
      }
    }
  }
})

MongoDB memastikan hanya data yang tervalidasi yang disimpan di koleksi.

Operasi CRUD

Inti dari bekerja dengan MongoDB adalah empat operasi dasar: create, read, update, dan delete, yang lebih dikenal sebagai CRUD.

Jika Anda bisa melakukan CRUD, Anda bisa membangun hampir semua aplikasi. MongoDB mempermudah ini dengan sejumlah metode yang intuitif. Mari kita bahas satu per satu.

Create

Untuk menambahkan dokumen baru ke koleksi di MongoDB, Anda menggunakan metode insertOne(). Sebagai contoh, kita dapat membuat dokumen pengguna baru di dalam koleksi user menggunakan kode di bawah ini.

db.users.insertOne({
  name: "Alice",
  email: "alice@example.com",
  age: 25
})

MongoDB secara otomatis menghasilkan _id unik untuk setiap dokumen yang dibuat.

Read

Membaca data dari koleksi sangat mudah. Kita cukup menggunakan find(). Kita bisa mendapatkan semua dokumen atau memfilter dengan kondisi. Kode di bawah ini dapat menemukan semua pengguna dari koleksi user.

// Find all users
db.users.find()

Kita dapat memfilter menggunakan kunci unik—misalnya email.

// Find one user by email
db.users.find({ email: "alice@example.com" })

find() selalu mengembalikan cursor (yang bisa Anda iterasi). Jika Anda hanya menginginkan satu kecocokan, Anda bisa menggunakan indOne().

Update

Setelah data dibuat, pasti ada kebutuhan untuk memodifikasinya. Untuk memodifikasi data, metode ``` updateOne()``` digunakan. Kita menentukan filter dan perubahan yang akan diterapkan.

// Update Alice’s age
db.users.updateOne(
  { email: "alice@example.com" },
  { $set: { age: 26 } }
)

Operator $set hanya memperbarui field yang ditentukan, sementara bagian lain dokumen tetap tidak berubah.

Delete

Terakhir, kita dapat menghapus dokumen dengan deleteOne() atau deleteMany(). Contoh di bawah ini menunjukkan aksi deleteOne.

// Delete Alice’s record
db.users.deleteOne({ email: "alice@example.com" })

Perlu dicatat bahwa penghapusan bersifat permanen.

Dengan hanya empat operasi ini, Anda dapat membangun segala sesuatu mulai dari aplikasi to-do hingga platform e-commerce.

Praktik Terbaik Keamanan

Keamanan tidak boleh menjadi pemikiran belakangan ketika berurusan dengan database. Dengan demikian, mari kita lihat praktik terbaik inti yang perlu diketahui pemula.

Autentikasi dan otorisasi

Secara default, instalasi MongoDB baru mungkin tidak menerapkan autentikasi. Itu berarti siapa pun yang dapat terhubung berpotensi mengakses data Anda. Ini bisa menjadi risiko besar jika tidak ditangani. Untuk memastikan MongoDB kita tidak dibiarkan terbuka, kita dapat menerapkan autentikasi dan otorisasi.

• Autentikasi memastikan hanya pengguna yang valid yang dapat terhubung.
• Otorisasi memastikan bahwa bahkan pengguna yang terautentikasi hanya dapat melakukan tindakan yang diizinkan.

Misalnya, alih-alih masuk sebagai pengguna root/admin di mana-mana, Anda sebaiknya membuat pengguna khusus untuk tugas tertentu.

// Create a new user with read-only access
db.createUser({
  user: "reportViewer",
  pwd: "strongPassword123",
  roles: [ { role: "read", db: "salesDB" } ]
})

Sekarang, pengguna ini hanya dapat membaca data dari salesDB, bukan menulis atau menghapus.

Role-based access control (RBAC)

MongoDB menggunakan role untuk mengelola apa yang dapat dilakukan pengguna. Beberapa role bawaan meliputi:

• Read: Pengguna dengan hak ini hanya dapat melihat data.
• ReadWrite: Pengguna dengan hak ini dapat melihat dan memodifikasi data.
• DbAdmin: Pengguna dengan hak ini dapat mengelola indeks, statistik, dan profiling.
• Root: Pengguna dengan hak ini memiliki kontrol penuh. Hindari menggunakan ini untuk pekerjaan sehari-hari!

Mengikuti prinsip least privilege memberikan pengguna izin yang mereka butuhkan untuk melakukan pekerjaan, sekaligus memastikan keamanan database MongoDB.

Hindari eksposur publik

Salah satu kesalahan pemula yang paling umum adalah membiarkan MongoDB mendengarkan pada port default (27017) dan bind ke 0.0.0.0 (semua antarmuka jaringan).

Itu berarti database Anda terbuka ke seluruh internet. Untuk mencegahnya, Anda harus mengambil langkah-langkah berikut:

• Bind MongoDB hanya ke localhost atau IP privat/internal.
• Gunakan firewall (atau security group cloud) untuk membatasi akses.
• Selalu terhubung melalui VPN atau SSH tunnel jika akses jarak jauh diperlukan.

# Example: /etc/mongod.conf

net:

  port: 27017

  bindIp: 127.0.0.1   # Only accessible locally

Dengan praktik-praktik ini, penerapan MongoDB Anda akan jauh lebih aman dari kebocoran yang tidak disengaja atau serangan berbahaya.

Kesimpulan

MongoDB telah menempatkan dirinya sebagai salah satu database teratas untuk aplikasi modern karena fleksibilitas dan kekuatannya. Baik Anda sedang bereksperimen dengan proyek sampingan atau mengelola sistem skala besar, memahami dasar-dasarnya dengan baik akan menghemat banyak waktu dan membantu Anda lebih produktif. Dalam artikel ini, kita membahas tujuh konsep kunci yang perlu diketahui pemula saat bekerja dengan MongoDB. Di antaranya:

• Memahami NoSQL dan database dokumen.
• Dasar-dasar arsitektur MongoDB.
• BSON dan tipe data.
• Prinsip desain skema.
• Validasi data.
• Operasi CRUD.
• Praktik terbaik keamanan.

Pemahaman yang baik atas konsep-konsep di atas akan memberi Anda fondasi yang kuat saat bekerja dengan MongoDB. Untuk detail lebih lanjut, pastikan untuk melihat MongoDB Docs dan kursus DataCamp Introduction to MongoDB in Python.