shell และ Compass

มีสามวิธีที่คุณจะคุยกับ MongoDB: shell mongosh สำหรับคำสั่งที่รวดเร็วและเขียนสคริปต์ได้; MongoDB Compass ที่เป็น graphical client ทางการ สำหรับคลิกไปมาและสำรวจ; และ driver ในภาษาของแอปพลิเคชันคุณสำหรับงานจริง บทเรียนนี้ครอบคลุมทั้งสามอย่าง โดยจบด้วยวิธีเปิดการเชื่อมต่อจากแต่ละสภาพแวดล้อมทั้งห้าที่คอร์สนี้ใช้

ทุกอันเชื่อมต่อด้วยที่อยู่ชนิดเดียวกัน — connection string — พอเข้าใจ connection string แล้ว การสลับไปมาระหว่างเครื่องมือก็ง่ายมาก

พื้นฐาน mongosh

mongosh เป็น JavaScript shell แบบโต้ตอบ คุณพิมพ์คำสั่ง shell ส่งไปรันบน server แล้วพิมพ์ผลลัพธ์กลับมา คำสั่งจำนวนหยิบมือเดียวครอบคลุมเกือบทุกอย่างที่คุณทำในแต่ละวัน:

show dbs

show dbs แสดงรายการ database บน server การจะเริ่มทำงานภายในอันใดอันหนึ่ง — เช่น database library — ให้ use เข้าไป โดย database ไม่ต้องมีอยู่ก่อน MongoDB จะสร้างให้ทันทีที่คุณเขียน document แรกลงไป:

use library

ตอนนี้ db อ้างถึง database library การอ่าน document ออกจาก collection คือ db.<collection>.find():

db.members.find()

เมื่อ query คืน document มากกว่าที่จะพอบนหน้าจอ mongosh แสดง batch แรกและพิมพ์ Type "it" for more การพิมพ์ it ดึง batch ถัดมา — it ย่อมาจาก iterate:

it

นั่นคือลูปหลัก: show dbs เพื่อดูว่ามีอะไรอยู่, use เพื่อเลือก database, db.coll.find() เพื่ออ่าน, และ it เพื่อแบ่งหน้าผ่านผลลัพธ์

ทัวร์ Compass

MongoDB Compass เป็น desktop GUI ทางการ และเป็นวิธีที่เป็นมิตรที่สุดในการสำรวจข้อมูลที่คุณยังไม่คุ้น คุณเชื่อมต่อโดยวาง connection string ลงในกล่องบนหน้าจอเริ่มต้น — สำหรับการตั้งค่า Docker บนเครื่องนั่นคืออะไรประมาณ mongodb://localhost:27017 หรือ mongodb://root:secret@localhost:27017 ถ้าคุณเปิดใช้ authentication — แล้วคลิก Connect

เมื่อเชื่อมต่อแล้ว แถบด้านข้างซ้ายแสดงรายการ database ของคุณ กางอันไหนออกก็จะเห็นรายการ collection ข้างใน คลิก collection แล้วจะเปิดขึ้นมา และตามด้านบนคุณจะได้แถวของ tab ที่ map เข้ากับสิ่งต่าง ๆ ที่คุณจะเรียนในคอร์สนี้:

tab Documents แสดง document จริง คุณเลื่อนดูได้ แก้ field ด้วยการดับเบิลคลิกที่ค่า และเพิ่ม document ใหม่ด้วยปุ่ม ADD DATA สีเขียวที่มุมขวาบน
tab Schema สุ่มตัวอย่าง collection และวาดภาพว่ามี field ใดอยู่บ้างและเก็บ type อะไร — เป็นวิธีที่รวดเร็วในการเข้าใจ collection ที่ไม่คุ้นเคยโดยไม่ต้องอ่านทุก document
tab Aggregations เป็นตัวสร้าง pipeline แบบ visual คุณเพิ่ม stage ทีละอันและเฝ้าดู document แปลงร่าง ซึ่งทำให้โมดูล aggregation ตามได้ง่ายขึ้นมาก
Explain Plan (มีให้เมื่อคุณรัน query) บอกว่า MongoDB รัน query นั้นอย่างไร ใช้ index หรือสแกนทั้งก้อน ที่เป็นหัวใจของโมดูล index

Compass และ shell ส่งเสริมกัน: Compass สำหรับการดูและสำรวจ, shell สำหรับการทำซ้ำและเขียนสคริปต์ ไม่มีอันไหนแทนที่ driver ในโค้ดแอปพลิเคชันของคุณ

การเชื่อมต่อจากแต่ละสภาพแวดล้อม

เมื่อถึงเวลาเขียนแอปพลิเคชัน คุณเชื่อมต่อด้วย driver connection string เหมือนเดิม ต่างกันแค่ API ที่ห่ออยู่รอบ ๆ นี่คือวิธีเปิดการเชื่อมต่อในทั้งห้าสภาพแวดล้อม โดย shell เริ่มจาก string ตรง ๆ ส่วน driver แต่ละตัวจะสร้าง client แล้วเช็กด้วย ping

mongosh "mongodb://localhost:27017"

import { MongoClient } from "mongodb";

const client = new MongoClient("mongodb://localhost:27017");
await client.connect();
await client.db("library").command({ ping: 1 });
console.log("connected");

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017")
client.admin.command("ping")
print("connected")

client, err := mongo.Connect(options.Client().ApplyURI("mongodb://localhost:27017"))
if err != nil {
    return err
}
if err := client.Ping(ctx, nil); err != nil {
    return err
}
fmt.Println("connected")

let client = Client::with_uri_str("mongodb://localhost:27017").await?;
client
    .database("library")
    .run_command(doc! { "ping": 1 })
    .await?;
println!("connected");

เมื่อ client ต่อติดแล้ว ให้ใช้ตัวเดิมซ้ำตลอดอายุของโปรแกรม การสร้าง client ใหม่ทุก request เป็นความผิดพลาดที่พบบ่อยและมีราคาแพง — client จัดการ pool ของการเชื่อมต่อที่ตั้งใจให้แชร์กัน

การเลือกเครื่องมือ

flowchart TD
  Q["What do you want to do"] --> S["Quick one-off command or a script"]
  Q --> C["Explore and understand unfamiliar data"]
  Q --> D["Build a feature in your app"]
  S --> SH["mongosh shell"]
  C --> CO["Compass GUI"]
  D --> DR["A driver in your language"]

เลือก shell สำหรับเขียนสคริปต์ Compass สำหรับสำรวจ และ driver สำหรับโค้ดแอปพลิเคชัน

เคล็ดลับและข้อควรระวัง

รูปแบบของ connection string คือ mongodb://[user:password@]host:port[/database] host และ port เป็นเพียงส่วนที่จำเป็น credential และ default database เป็น optional
ใช้ shell vs Compass vs driver ตามเจตนา: shell สำหรับคำสั่งที่เร็วและทำซ้ำได้, Compass สำหรับการสำรวจแบบ visual และการค้นพบ schema, และ driver สำหรับอะไรก็ตามที่แอปพลิเคชันของคุณทำบน production
Authentication เปลี่ยน string ไม่ใช่ workflow ถ้าคุณตั้ง root user ในบทเรียน Docker ให้ใส่ root:secret@ ไว้ก่อน host ในทุกเครื่องมือ
ใช้ client เดียวซ้ำ driver ทั้งหมดถูกสร้างขึ้นรอบ ๆ object client ที่มีอายุยืนพร้อม connection pool ภายใน สร้างครั้งเดียวตอน start แล้วใช้ยาว

ข้อแลกเปลี่ยน

ตัวเลือก	Benefit	Cost
mongosh	เขียนสคริปต์และทำงานซ้ำ ๆ ได้เร็ว รันผ่าน SSH บน server ที่ไม่มี GUI ได้ และ automate เป็นไฟล์ `.js` ได้	ต้องจำ syntax คำสั่งและชื่อ field เอง ไม่มีภาพช่วยตอนสำรวจข้อมูลที่ไม่คุ้นเคย
Compass (GUI)	เห็นภาพ schema และ document จริงได้ทันที สร้าง aggregation pipeline แบบลากวางทีละ stage ทำให้เข้าใจข้อมูลใหม่ได้เร็ว	ต้องมีหน้าจอ ใช้ผ่าน SSH หรือ automate ในสคริปต์ไม่ได้ และเปิดแอปหนักกว่าการพิมพ์คำสั่งเดียวใน terminal

ข้อผิดพลาดที่พบบ่อย

ใช้ Compass เป็นเครื่องมือ automate งานประจำ — Compass ออกแบบมาให้คลิกสำรวจ ไม่ใช่รันซ้ำเป็น pipeline อัตโนมัติ งานที่ต้องรันซ้ำทุกวันควรเป็นสคริปต์ mongosh หรือ driver แทน
สร้าง client ใหม่ในโค้ดแอปพลิเคชันทุก request — driver ตั้งใจให้สร้าง client อายุยืนแค่ครั้งเดียวแล้วใช้ connection pool ซ้ำ การสร้างใหม่ทุก request เปิด/ปิด connection โดยไม่จำเป็นและทำให้ช้าลงมาก
คิดว่า mongosh กับ driver ใช้ syntax เดียวกัน 100% — mongosh เป็น JavaScript shell ที่มี helper เฉพาะตัวอย่าง use, show dbs, it ซึ่งไม่มีใน driver จริง driver แต่ละภาษาต้องเรียก method ที่ตรงกับ API ของตัวเอง ไม่ใช่ copy คำสั่ง shell ไปวางตรง ๆ

💡 ตัวอย่างจากของจริง

ทีม on-call / SRE — ต่อเข้า server production ผ่าน SSH แล้วใช้ mongosh รัน query ตรวจสอบสถานะเร็ว ๆ เพราะไม่มี GUI ให้ใช้และต้องการความเร็วตอนแก้ปัญหากลางดึก

ทีม data / analyst — ใช้ Compass เปิดดู collection ที่ไม่คุ้นเคยก่อน แล้วใช้ตัวสร้าง aggregation pipeline แบบ visual ประกอบ stage ทีละอันจนได้ pipeline ที่ถูกต้อง ก่อนค่อยคัดลอกไปฝังในโค้ดจริง