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.
