MongoDB adalah database NoSQL yang flexible dan scalable. Mari pelajari cara menggunakannya.

Install MongoDB

Ubuntu/Debian

# Import public key
curl -fsSL https://pgp.mongodb.com/server-7.0.asc | \
   sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg \
   --dearmor
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] 
https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | \
sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
Install
sudo apt update
sudo apt install -y mongodb-org
Start service
sudo systemctl start mongod
sudo systemctl enable mongod
Verify
mongosh

Docker

docker run -d \
    --name mongodb \
    -p 27017:27017 \
    -v mongodb-data:/data/db \
    -e MONGO_INITDB_ROOT_USERNAME=admin \
    -e MONGO_INITDB_ROOT_PASSWORD=password \
    mongo:7

MongoDB Shell (mongosh)

Basic Commands

// Show databases
show dbs
// Use/create database
use mydb
// Show collections
show collections
// Create collection
db.createCollection("users")
// Drop database
db.dropDatabase()
// Drop collection
db.users.drop()

CRUD Operations

Create (Insert)

// Insert one document
db.users.insertOne({
  name: "Budi",
  email: "[email protected]",
  age: 25,
  roles: ["user", "admin"],
  address: {
    city: "Jakarta",
    zip: "12345",
  },
  createdAt: new Date(),
});
// Insert many documents
db.users.insertMany([
{ name: "Ani", email: "[email protected]", age: 23 },
{ name: "Citra", email: "[email protected]", age: 28 },
{ name: "Deni", email: "[email protected]", age: 30 },
]);

Read (Find)

// Find all
db.users.find();
// Find with pretty print
db.users.find().pretty();
// Find one
db.users.findOne({ name: "Budi" });
// Find with conditions
db.users.find({ age: { $gt: 25 } });
db.users.find({ age: { $gte: 25, $lte: 30 } });
db.users.find({ name: { $in: ["Budi", "Ani"] } });
// Find with AND
db.users.find({
age: { $gt: 20 },
"address.city": "Jakarta",
});
// Find with OR
db.users.find({
$or: [{ age: { $lt: 25 } }, { roles: "admin" }],
});
// Projection (select fields)
db.users.find({}, { name: 1, email: 1, _id: 0 });
// Sort
db.users.find().sort({ age: 1 }); // Ascending
db.users.find().sort({ age: -1 }); // Descending
// Limit and skip
db.users.find().limit(10);
db.users.find().skip(10).limit(10); // Pagination
// Count
db.users.countDocuments({ age: { $gt: 25 } });

Update

// Update one
db.users.updateOne({ name: "Budi" }, { $set: { age: 26 } });
// Update many
db.users.updateMany({ age: { $lt: 25 } }, { $set: { status: "junior" } });
// Increment
db.users.updateOne({ name: "Budi" }, { $inc: { age: 1 } });
// Push to array
db.users.updateOne({ name: "Budi" }, { $push: { roles: "editor" } });
// Pull from array
db.users.updateOne({ name: "Budi" }, { $pull: { roles: "user" } });
// Upsert (insert if not exists)
db.users.updateOne(
{ email: "[email protected]" },
{ $set: { name: "New User", age: 20 } },
{ upsert: true }
);
// Replace document
db.users.replaceOne(
{ name: "Budi" },
{ name: "Budi", email: "[email protected]", age: 27 }
);

Delete

// Delete one
db.users.deleteOne({ name: "Budi" });
// Delete many
db.users.deleteMany({ age: { $lt: 20 } });
// Delete all
db.users.deleteMany({});

Indexes

Create Indexes

// Single field index
db.users.createIndex({ email: 1 });
// Compound index
db.users.createIndex({ name: 1, age: -1 });
// Unique index
db.users.createIndex({ email: 1 }, { unique: true });
// Text index
db.articles.createIndex({ title: "text", content: "text" });
// TTL index (auto-delete after time)
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 });

Index Management

// List indexes
db.users.getIndexes();
// Drop index
db.users.dropIndex("email_1");
// Explain query (show index usage)
db.users.find({ email: "[email protected]" }).explain("executionStats");

Aggregation Pipeline

Basic Aggregation

// Match and group
db.orders.aggregate([
  { $match: { status: "completed" } },
  {
    $group: {
      _id: "$customerId",
      totalAmount: { $sum: "$amount" },
      orderCount: { $sum: 1 },
    },
  },
  { $sort: { totalAmount: -1 } },
  { $limit: 10 },
]);

Common Stages

// $match - Filter documents
{ $match: { status: "active" } }
// $group - Group and aggregate
{ $group: {
_id: "$category",
total: { $sum: "$price" },
average: { $avg: "$price" },
count: { $sum: 1 },
items: { $push: "$name" }
}}
// $project - Shape output
{ $project: {
name: 1,
email: 1,
fullName: { $concat: ["$firstName", " ", "$lastName"] },
_id: 0
}}
// $lookup - Join collections
{ $lookup: {
from: "orders",
localField: "_id",
foreignField: "userId",
as: "userOrders"
}}
// $unwind - Deconstruct array
{ $unwind: "$tags" }
// $sort
{ $sort: { createdAt: -1 } }
// $skip and $limit
{ $skip: 10 }
{ $limit: 10 }

Complex Example

db.orders.aggregate([
  // Filter by date
  {
    $match: {
      createdAt: {
        $gte: new Date("2026-01-01"),
        $lt: new Date("2026-02-01"),
      },
    },
  },
  // Join with products
  {
    $lookup: {
      from: "products",
      localField: "productId",
      foreignField: "_id",
      as: "product",
    },
  },
  // Unwind product array
  { $unwind: "$product" },
  // Group by category
  {
    $group: {
      _id: "$product.category",
      totalRevenue: { $sum: "$amount" },
      totalOrders: { $sum: 1 },
      avgOrderValue: { $avg: "$amount" },
    },
  },
  // Sort by revenue
  { $sort: { totalRevenue: -1 } },
  // Format output
  {
    $project: {
      category: "$_id",
      totalRevenue: { $round: ["$totalRevenue", 2] },
      totalOrders: 1,
      avgOrderValue: { $round: ["$avgOrderValue", 2] },
      _id: 0,
    },
  },
]);

Node.js Integration

Install Driver

npm install mongodb

Connection

const { MongoClient } = require("mongodb");
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri);
async function connect() {
try {
await client.connect();
console.log("Connected to MongoDB");
return client.db("mydb");
} catch (error) {
console.error("Connection error:", error);
throw error;
}
}
module.exports = { client, connect };

CRUD with Node.js

const { connect, client } = require("./db");
async function main() {
const db = await connect();
const users = db.collection("users");
// Insert
const result = await users.insertOne({
name: "Budi",
email: "[email protected]",
});
console.log("Inserted ID:", result.insertedId);
// Find
const user = await users.findOne({ name: "Budi" });
console.log("Found:", user);
// Find many
const allUsers = await users.find({ age: { $gt: 20 } }).toArray();
console.log("All users:", allUsers);
// Update
await users.updateOne({ name: "Budi" }, { $set: { age: 26 } });
// Delete
await users.deleteOne({ name: "Budi" });
// Close connection
await client.close();
}
main().catch(console.error);

With Mongoose (ODM)

// npm install mongoose
const mongoose = require("mongoose");
// Connect
mongoose.connect("mongodb://localhost:27017/mydb");
// Define Schema
const userSchema = new mongoose.Schema({
name: { type: String, required: true },
email: { type: String, required: true, unique: true },
age: { type: Number, min: 0 },
roles: [String],
createdAt: { type: Date, default: Date.now },
});
// Create Model
const User = mongoose.model("User", userSchema);
// CRUD Operations
async function example() {
// Create
const user = new User({
name: "Budi",
email: "[email protected]",
age: 25,
});
await user.save();
// Find
const users = await User.find({ age: { $gt: 20 } });
const oneUser = await User.findOne({ email: "[email protected]" });
// Update
await User.findByIdAndUpdate(user._id, { age: 26 });
// Delete
await User.findByIdAndDelete(user._id);
}

Data Modeling

Embedded Documents

// Good for: 1-to-few, frequently accessed together
{
    _id: ObjectId("..."),
    name: "Budi",
    addresses: [
        { type: "home", city: "Jakarta" },
        { type: "work", city: "Bandung" }
    ],
    orders: [
        { productId: "...", amount: 100000 },
        { productId: "...", amount: 200000 }
    ]
}

References

// Good for: 1-to-many, many-to-many, large documents
// User document
{
    _id: ObjectId("user1"),
    name: "Budi"
}
// Order documents (reference user)
{
_id: ObjectId("order1"),
userId: ObjectId("user1"),
amount: 100000
}

Kesimpulan

MongoDB adalah database NoSQL yang flexible untuk aplikasi modern. Pahami kapan menggunakan embedded vs references, dan optimize dengan indexes.