🍃 Jak używać serwera MongoDB do przechowywania i zarządzania danymi

MongoDB to jedna z najpopularniejszych baz danych NoSQL, która rewolucjonizuje sposób przechowywania i zarządzania danymi w aplikacjach webowych i mobilnych. Dzięki swojej elastycznej strukturze dokumentów, wysokiej wydajności i łatwej skalowalności, MongoDB pozwala na efektywne operowanie danymi o zmiennej strukturze. W tym przewodniku poznasz wszystkie aspekty pracy z MongoDB - od instalacji, przez podstawowe operacje, po zaawansowane techniki zarządzania danymi.

⚡ Ekspresowe Podsumowanie:

  1. Elastyczna struktura danych: MongoDB przechowuje dane w formacie podobnym do JSON, co pozwala na łatwe adaptowanie struktury do zmieniających się potrzeb aplikacji.
  2. Wysoka wydajność i skalowalność: Dzięki indeksom, replikacji i shardingu, MongoDB oferuje znakomitą wydajność nawet przy ogromnych zbiorach danych.
  3. Bogaty ekosystem narzędzi: MongoDB Compass, MongoDB Atlas i inne narzędzia ułatwiają zarządzanie i monitorowanie bazy danych.
  4. Natywna integracja z językami programowania: Sterowniki dla najpopularniejszych języków pozwalają na łatwą pracę z MongoDB w twoich aplikacjach.

🗺️ Spis Treści - Twoja Mapa Drogowa

📌 Czym jest MongoDB i kiedy go używać?

MongoDB to nowoczesna, nierelacyjna baza danych, która przechowuje dane w elastycznych, podobnych do JSON dokumentach. W przeciwieństwie do tradycyjnych baz relacyjnych, MongoDB nie wymaga predefiniowanego schematu, co pozwala na łatwą adaptację do zmieniających się wymagań aplikacji.

Kluczowe cechy MongoDB:

  • Baza dokumentowa - dane są przechowywane w dokumentach BSON (binarny JSON)
  • Elastyczny schemat - pola mogą się różnić między dokumentami, łatwa adaptacja do zmian
  • Wysoka wydajność - indeksy, wbudowane funkcje agregacji, operacje atomowe
  • Pozioma skalowalność - replikacja i sharding (fragmentacja) dla obsługi dużych obciążeń
  • Bogaty ekosystem - narzędzia, usługi chmurowe (MongoDB Atlas), integracje

Kiedy warto używać MongoDB:

MongoDB jest szczególnie dobrym wyborem dla:

  • Aplikacji z dynamiczną strukturą danych - gdy schemat często się zmienia
  • Dużych zestawów danych - gdy wydajność i skalowalność są kluczowe
  • Aplikacji zarządzających treścią (CMS) - elastyczne przechowywanie różnych typów treści
  • Aplikacji mobilnych i webowych - szybki rozwój i elastyczne dostosowywanie
  • Aplikacji czasu rzeczywistego - analityka, IoT, systemy rekomendacji
  • Przechowywania danych hierarchicznych - zagnieżdżone dokumenty ułatwiają pracę

✨ Pro Tip: MongoDB nie jest dobrym wyborem dla aplikacji z silnymi zależnościami między danymi (relacjami) lub wymagających wielotabelowych transakcji. W takich przypadkach tradycyjne bazy SQL mogą być lepszym wyborem.

🔧 Instalacja i konfiguracja MongoDB

Instalacja MongoDB na systemach Linux

Ubuntu:

# Importuj klucz publiczny MongoDB
wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -

# Utwórz plik listy dla MongoDB
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list

# Zaktualizuj listę pakietów
sudo apt-get update

# Zainstaluj MongoDB
sudo apt-get install -y mongodb-org

# Uruchom i włącz usługę MongoDB
sudo systemctl start mongod
sudo systemctl enable mongod

CentOS/RHEL:

# Utwórz plik repozytorium MongoDB
sudo nano /etc/yum.repos.d/mongodb-org-6.0.repo

# Dodaj następującą zawartość:
[mongodb-org-6.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/6.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-6.0.asc

# Zainstaluj MongoDB
sudo yum install -y mongodb-org

# Uruchom i włącz usługę MongoDB
sudo systemctl start mongod
sudo systemctl enable mongod

Instalacja na Windows

  1. Pobierz instalator MSI ze strony MongoDB Download Center
  2. Uruchom instalator i postępuj zgodnie z instrukcjami
  3. Wybierz opcję "Complete" dla pełnej instalacji
  4. Opcjonalnie zainstaluj MongoDB jako usługę

Instalacja na macOS

Przy użyciu Homebrew:

brew tap mongodb/brew
brew install mongodb-community
brew services start mongodb-community

Sprawdzenie instalacji

Po instalacji możesz sprawdzić, czy MongoDB działa poprawnie:

mongo --version  # Sprawdzenie wersji klienta (starszy klient)
mongosh --version  # Sprawdzenie wersji MongoDB Shell (nowszy klient)

# Połączenie z bazą danych
mongosh

Po połączeniu powinieneś zobaczyć powłokę MongoDB, gdzie możesz wykonać proste polecenie, aby sprawdzić, czy baza danych działa:

db.version()  // Wyświetla wersję serwera MongoDB

Podstawowa konfiguracja zabezpieczeń

Po instalacji MongoDB domyślnie nie ma włączonej autoryzacji. Aby zabezpieczyć swoją bazę danych:

  1. Utwórz użytkownika administratora:
use admin

db.createUser({
  user: "adminUser",
  pwd: "securePassword",
  roles: [{ role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase"]
})
  1. Włącz autoryzację, edytując plik konfiguracyjny MongoDB (/etc/mongod.conf):
security:
  authorization: enabled
  1. Zrestartuj usługę MongoDB:
sudo systemctl restart mongod
  1. Teraz połącz się z zabezpieczoną bazą danych:
mongosh --authenticationDatabase admin -u adminUser -p

Uwaga: W środowisku produkcyjnym należy dodatkowo rozważyć szyfrowanie danych, konfigurację firewalla i regularne tworzenie kopii zapasowych.

🧱 Podstawowe pojęcia i struktura MongoDB

Zrozumienie kluczowych pojęć i struktury MongoDB jest niezbędne do efektywnej pracy z tą bazą danych:

Hierarchia danych w MongoDB

  1. Baza danych - kontener na kolekcje, podobny do bazy danych w systemach SQL
  2. Kolekcja - grupa dokumentów, odpowiednik tabeli w bazach relacyjnych
  3. Dokument - pojedynczy rekord danych, odpowiednik wiersza w tabeli
  4. Pole - para klucz-wartość w dokumencie, odpowiednik kolumny w tabeli

Format dokumentów BSON

MongoDB przechowuje dane w formacie BSON (Binary JSON), który rozszerza JSON o dodatkowe typy danych i jest zoptymalizowany pod kątem wydajności.

Przykładowy dokument MongoDB:

{
  "_id": ObjectId("5f8d4e9a7f6ed938a7db9715"),
  "name": "Jan Kowalski",
  "email": "jan.kowalski@example.com",
  "age": 28,
  "address": {
    "street": "ul. Przykładowa 123",
    "city": "Warszawa",
    "zipCode": "00-001"
  },
  "tags": ["klient", "premium", "aktywny"],
  "createdAt": ISODate("2023-05-01T12:30:45Z")
}

Typy danych BSON

MongoDB obsługuje różne typy danych, w tym:

  • String - łańcuchy znaków UTF-8
  • Integer (32-bit lub 64-bit) - liczby całkowite
  • Double - liczby zmiennoprzecinkowe
  • Boolean - wartości true/false
  • Date - data i czas
  • ObjectId - 12-bajtowy identyfikator, domyślnie używany dla pola _id
  • Array - tablice wartości
  • Embedded Document - zagnieżdżone dokumenty
  • Null - wartość null
  • Timestamp - znacznik czasu

✨ Pro Tip: Pole _id jest automatycznie dodawane do każdego dokumentu jako klucz podstawowy, jeśli nie zostanie określone inaczej.

🔍 Podstawowe operacje CRUD

CRUD to akronim od Create, Read, Update, Delete - podstawowe operacje wykonywane na danych w bazie.

Podłączenie do bazy danych

mongosh "mongodb://localhost:27017"

# Z autentykacją
mongosh "mongodb://username:password@localhost:27017/database"

Tworzenie bazy danych i kolekcji

// Przełączenie na bazę danych (tworzy ją, jeśli nie istnieje)
use my_database

// Utworzenie kolekcji
db.createCollection("users")

// Alternatywnie, kolekcja zostanie utworzona automatycznie przy pierwszym wstawieniu
db.products.insertOne({ name: "Laptop", price: 3500 })

Create - Dodawanie dokumentów

// Dodawanie pojedynczego dokumentu
db.users.insertOne({
  name: "Anna Nowak",
  email: "anna@example.com",
  age: 32,
  active: true
})

// Dodawanie wielu dokumentów
db.users.insertMany([
  {
    name: "Piotr Wiśniewski",
    email: "piotr@example.com",
    age: 45,
    active: false
  },
  {
    name: "Marta Kowalska",
    email: "marta@example.com",
    age: 27,
    active: true
  }
])

Read - Odczytywanie dokumentów

// Pobranie wszystkich dokumentów z kolekcji
db.users.find()

// Formatowanie wyniku dla lepszej czytelności
db.users.find().pretty()

// Filtrowanie z określonym warunkiem
db.users.find({ age: { $gt: 30 } })  // Użytkownicy starsi niż 30 lat

// Filtrowanie z wieloma warunkami
db.users.find({ age: { $gt: 30 }, active: true })

// Odczytanie pojedynczego dokumentu
db.users.findOne({ name: "Anna Nowak" })

// Projekcja - wybór określonych pól
db.users.find({}, { name: 1, email: 1, _id: 0 })  // Tylko name i email, bez _id

// Limitowanie wyników
db.users.find().limit(5)

// Sortowanie wyników
db.users.find().sort({ age: 1 })  // 1 rosnąco, -1 malejąco

// Paginacja
db.users.find().skip(10).limit(10)  // Druga strona wyników (10-19)

Update - Aktualizowanie dokumentów

// Aktualizacja jednego dokumentu
db.users.updateOne(
  { name: "Anna Nowak" },
  { $set: { email: "anna.nowak@example.com", age: 33 } }
)

// Aktualizacja wielu dokumentów
db.users.updateMany(
  { active: false },
  { $set: { inactive: true } }
)

// Zwiększenie wartości liczbowej
db.users.updateOne(
  { name: "Anna Nowak" },
  { $inc: { age: 1 } }  // Zwiększenie wieku o 1
)

// Dodanie elementu do tablicy
db.users.updateOne(
  { name: "Anna Nowak" },
  { $push: { tags: "vip" } }
)

// Usunięcie pola
db.users.updateOne(
  { name: "Anna Nowak" },
  { $unset: { inactive: "" } }
)

// Aktualizacja z upsert (insert jeśli nie istnieje)
db.users.updateOne(
  { email: "nowy@example.com" },
  { $set: { name: "Nowy Użytkownik", age: 25 } },
  { upsert: true }
)

Delete - Usuwanie dokumentów

// Usunięcie jednego dokumentu
db.users.deleteOne({ name: "Anna Nowak" })

// Usunięcie wielu dokumentów
db.users.deleteMany({ active: false })

// Usunięcie wszystkich dokumentów z kolekcji
db.users.deleteMany({})

// Usunięcie całej kolekcji
db.users.drop()

// Usunięcie bazy danych
db.dropDatabase()

✨ Pro Tip: Zawsze używaj filtrów przy operacjach usuwania, aby uniknąć przypadkowego usunięcia wszystkich danych.

📊 Zaawansowane zapytania i operatory

MongoDB oferuje bogaty zestaw operatorów do zaawansowanego filtrowania i manipulowania danymi.

Operatory porównania

// Równość
db.products.find({ price: 100 })

// Większe niż
db.products.find({ price: { $gt: 100 } })

// Większe lub równe
db.products.find({ price: { $gte: 100 } })

// Mniejsze niż
db.products.find({ price: { $lt: 100 } })

// Mniejsze lub równe
db.products.find({ price: { $lte: 100 } })

// Nierówność
db.products.find({ price: { $ne: 100 } })

// W zakresie
db.products.find({ price: { $in: [100, 200, 300] } })

// Poza zakresem
db.products.find({ price: { $nin: [100, 200, 300] } })

Operatory logiczne

// AND (domyślnie przy wielu warunkach)
db.products.find({ category: "electronics", price: { $lt: 1000 } })

// Lub jawnie
db.products.find({ $and: [{ category: "electronics" }, { price: { $lt: 1000 } }] })

// OR
db.products.find({ $or: [{ category: "electronics" }, { price: { $lt: 500 } }] })

// NOT
db.products.find({ category: { $not: { $eq: "clothing" } } })

// NOR
db.products.find({ $nor: [{ price: { $gt: 1000 } }, { quantity: { $lt: 10 } }] })

Operatory elementów

// Sprawdzenie istnienia pola
db.products.find({ description: { $exists: true } })

// Sprawdzenie typu danych
db.products.find({ price: { $type: "number" } })

Operatory tablicowe

// Dokładne dopasowanie tablicy
db.products.find({ tags: ["premium", "sale"] })

// Zawiera element
db.products.find({ tags: "premium" })

// Zawiera wszystkie elementy
db.products.find({ tags: { $all: ["premium", "sale"] } })

// Rozmiar tablicy
db.products.find({ tags: { $size: 3 } })

// Element na określonej pozycji
db.products.find({ "tags.0": "premium" })

// Element spełnia warunek
db.products.find({ tags: { $elemMatch: { $eq: "premium" } } })

Operatory wyrażeń regularnych

// Wyszukiwanie z regex
db.products.find({ name: /^Lap/ })  // Nazwy zaczynające się od "Lap"

// Lub z operatorem $regex
db.products.find({ name: { $regex: "^Lap", $options: "i" } })  // Opcja "i" dla ignorowania wielkości liter

🚀 Agregacja danych

Framework agregacji MongoDB to potężne narzędzie do przetwarzania i analizy danych. Pozwala na wykonywanie złożonych operacji, takich jak grupowanie, filtrowanie i transformacje danych.

Podstawowa struktura potoku agregacji

db.collection.aggregate([
  { $stage1: { <parameters> } },
  { $stage2: { <parameters> } },
  ...
])

Popularne etapy agregacji

$match - filtrowanie dokumentów

db.orders.aggregate([
  { $match: { status: "completed", total: { $gt: 100 } } }
])

$group - grupowanie danych

// Suma sprzedaży według kategorii
db.orders.aggregate([
  { $group: { 
      _id: "$category", 
      totalSales: { $sum: "$amount" },
      count: { $sum: 1 } 
    } 
  }
])

// Grupowanie według wielu pól
db.orders.aggregate([
  { $group: { 
      _id: { month: { $month: "$date" }, year: { $year: "$date" } }, 
      totalSales: { $sum: "$amount" } 
    } 
  }
])

$project - wybór i transformacja pól

db.users.aggregate([
  { $project: { 
      name: 1, 
      firstLetter: { $substr: ["$name", 0, 1] },
      age: 1,
      ageGroup: { 
        $switch: {
          branches: [
            { case: { $lt: ["$age", 18] }, then: "under 18" },
            { case: { $lt: ["$age", 30] }, then: "18-29" },
            { case: { $lt: ["$age", 50] }, then: "30-49" }
          ],
          default: "50+"
        }
      }
    } 
  }
])

$sort - sortowanie wyników

db.products.aggregate([
  { $sort: { price: -1 } }  // Sortowanie malejąco według ceny
])

$limit i $skip - paginacja

db.products.aggregate([
  { $skip: 10 },
  { $limit: 10 }
])

$unwind - rozwinięcie tablicy

// Dla dokumentu z tablicą tagów, tworzy osobny dokument dla każdego tagu
db.products.aggregate([
  { $unwind: "$tags" }
])

$lookup - łączenie kolekcji (podobne do JOIN w SQL)

db.orders.aggregate([
  { $lookup: {
      from: "customers",
      localField: "customer_id",
      foreignField: "_id",
      as: "customer_info"
    }
  }
])

Przykład złożonego potoku agregacji

db.sales.aggregate([
  // Filtruj sprzedaż za 2023 rok
  { $match: { 
      date: { 
        $gte: new Date("2023-01-01"), 
        $lt: new Date("2024-01-01") 
      } 
    }
  },

  // Rozwiń tablicę produktów
  { $unwind: "$products" },

  // Grupuj według kategorii produktu i miesiąca
  { $group: {
      _id: { 
        category: "$products.category", 
        month: { $month: "$date" }
      },
      totalSales: { $sum: { $multiply: ["$products.price", "$products.quantity"] } },
      count: { $sum: 1 }
    }
  },

  // Sortuj według kategorii i miesiąca
  { $sort: { "_id.category": 1, "_id.month": 1 } },

  // Formatuj wyniki
  { $project: {
      category: "$_id.category",
      month: "$_id.month",
      totalSales: 1,
      count: 1,
      averageSale: { $divide: ["$totalSales", "$count"] },
      _id: 0
    }
  }
])

✨ Pro Tip: Dla złożonych agregacji warto używać MongoDB Compass, które oferuje intuicyjny interfejs do budowania i testowania potoków agregacji.

🏎️ Indeksy i optymalizacja wydajności

Indeksy są kluczowym elementem optymalizacji wydajności MongoDB, szczególnie dla dużych kolekcji.

Tworzenie indeksów

// Indeks na pojedynczym polu
db.users.createIndex({ email: 1 })  // 1 rosnąco, -1 malejąco

// Indeks złożony (na wielu polach)
db.products.createIndex({ category: 1, price: -1 })

// Indeks unikalny
db.users.createIndex({ email: 1 }, { unique: true })

// Indeks tekstowy
db.articles.createIndex({ title: "text", content: "text" })

// Indeks geograficzny
db.places.createIndex({ location: "2dsphere" })

// Indeks częściowy
db.orders.createIndex(
  { status: 1 },
  { partialFilterExpression: { total: { $gt: 1000 } } }
)

// Indeks TTL (Time-To-Live)
db.sessions.createIndex(
  { lastModified: 1 },
  { expireAfterSeconds: 3600 }  // Usuwa dokumenty po 1h
)

Zarządzanie indeksami

// Lista wszystkich indeksów w kolekcji
db.users.getIndexes()

// Usunięcie indeksu
db.users.dropIndex("email_1")

// Usunięcie wszystkich indeksów (oprócz _id)
db.users.dropIndexes()

// Przebudowanie indeksów
db.users.reIndex()

Analizowanie wydajności zapytań

// Wyjaśnienie planu zapytania
db.users.find({ age: { $gt: 30 } }).explain()

// Szczegółowe wyjaśnienie z informacjami o wykonaniu
db.users.find({ age: { $gt: 30 } }).explain("executionStats")

// Monitorowanie czasu wykonania
db.users.find({ age: { $gt: 30 } }).explain("executionStats").executionStats.executionTimeMillis

Najlepsze praktyki optymalizacji

  1. Indeksuj pola używane w zapytaniach - szczególnie te używane do filtrowania, sortowania i łączenia.
  2. Unikaj indeksowania wszystkiego - każdy indeks zajmuje miejsce i spowalnia operacje zapisu.
  3. Używaj indeksów złożonych dla zapytań z wieloma warunkami.
  4. Rozważ indeksy pokrywające (covered) - zawierające wszystkie pola zapytania, co eliminuje potrzebę dostępu do dokumentów.
  5. Monitoruj wydajność zapytań za pomocą explain() i narzędzi, takich jak MongoDB Compass.
  6. Używaj projekcji ({ field: 1 }) aby ograniczyć ilość danych przesyłanych z bazy.
  7. Paginate wyniki za pomocą limit() i skip().

Uwaga: Indeksy znacząco przyspieszają odczyt, ale spowalniają operacje zapisu, ponieważ każdy indeks musi być aktualizowany. Znajdź odpowiednią równowagę dla swoich potrzeb.

🧪 MongoDB w praktycznych zastosowaniach

Modelowanie danych w MongoDB

W przeciwieństwie do baz relacyjnych, MongoDB oferuje elastyczność w modelowaniu danych. Istnieją dwa główne podejścia:

1. Modelowanie z dokumentami zagnieżdżonymi (Embedded Documents)

db.customers.insertOne({
  _id: ObjectId("..."),
  name: "Jan Kowalski",
  contact: {
    email: "jan@example.com",
    phone: "123-456-789"
  },
  addresses: [
    {
      type: "billing",
      street: "ul. Lipowa 1",
      city: "Warszawa",
      zipCode: "00-123"
    },
    {
      type: "shipping",
      street: "ul. Brzozowa 5",
      city: "Kraków",
      zipCode: "30-456"
    }
  ],
  orders: [
    {
      date: ISODate("2023-01-15"),
      items: [
        { product: "Laptop", price: 3500, quantity: 1 }
      ],
      total: 3500
    }
  ]
})

2. Modelowanie z referencjami (References)

// Kolekcja klientów
db.customers.insertOne({
  _id: ObjectId("5f8d4..."),
  name: "Jan Kowalski",
  email: "jan@example.com"
})

// Kolekcja adresów
db.addresses.insertMany([
  {
    _id: ObjectId("5f8e1..."),
    customer_id: ObjectId("5f8d4..."),
    type: "billing",
    street: "ul. Lipowa 1",
    city: "Warszawa"
  },
  {
    _id: ObjectId("5f8e2..."),
    customer_id: ObjectId("5f8d4..."),
    type: "shipping",
    street: "ul. Brzozowa 5",
    city: "Kraków"
  }
])

// Kolekcja zamówień
db.orders.insertOne({
  _id: ObjectId("5f8f3..."),
  customer_id: ObjectId("5f8d4..."),
  date: ISODate("2023-01-15"),
  total: 3500
})

// Kolekcja elementów zamówienia
db.orderItems.insertOne({
  order_id: ObjectId("5f8f3..."),
  product: "Laptop",
  price: 3500,
  quantity: 1
})

Kiedy używać którego podejścia?

  • Dokumenty zagnieżdżone - gdy dane są używane razem, mają relację "należy do" i nie są aktualizowane niezależnie.
  • Referencje - gdy dane są używane w wielu miejscach, aktualizowane niezależnie lub bardzo duże.

Przykładowe zastosowania MongoDB

System zarządzania treścią (CMS)

// Kolekcja artykułów
db.articles.insertOne({
  title: "Wprowadzenie do MongoDB",
  slug: "wprowadzenie-do-mongodb",
  content: "MongoDB to baza danych NoSQL...",
  author: {
    name: "Anna Kowalska",
    email: "anna@example.com"
  },
  categories: ["bazy danych", "NoSQL", "tutorial"],
  tags: ["mongodb", "database", "nosql"],
  publishedDate: ISODate("2023-04-15"),
  status: "published",
  comments: [
    {
      user: "Jan Nowak",
      email: "jan@example.com",
      content: "Świetny artykuł!",
      date: ISODate("2023-04-16")
    }
  ]
})

// Wyszukiwanie artykułów po słowach kluczowych
db.articles.find({
  $text: { $search: "mongodb nosql" }
})

// Ostatnie artykuły z określonej kategorii
db.articles.find(
  { categories: "NoSQL", status: "published" }
).sort({ publishedDate: -1 }).limit(5)

Aplikacja e-commerce

// Wyszukiwanie produktów z filtrowaniem i sortowaniem
db.products.find({
  category: "Electronics",
  price: { $gte: 1000, $lte: 5000 },
  "stock.status": "in_stock"
}).sort({ price: 1 })

// Agregacja do analizy sprzedaży
db.orders.aggregate([
  { $match: { status: "completed" } },
  { $unwind: "$items" },
  { $group: {
      _id: "$items.product_id",
      totalSold: { $sum: "$items.quantity" },
      revenue: { $sum: { $multiply: ["$items.price", "$items.quantity"] } }
    }
  },
  { $sort: { revenue: -1 } },
  { $limit: 10 }
])

Monitorowanie IoT

// Wstawianie danych z czujników
db.sensorData.insertOne({
  device_id: "termo-001",
  type: "temperature",
  value: 22.5,
  unit: "C",
  timestamp: ISODate("2023-05-01T12:30:45Z"),
  location: {
    type: "Point",
    coordinates: [21.0122, 52.2297]  // [longitude, latitude]
  }
})

// Agregacja do obliczania średnich wartości
db.sensorData.aggregate([
  { $match: { 
      type: "temperature", 
      timestamp: { 
        $gte: ISODate("2023-05-01"), 
        $lt: ISODate("2023-05-02") 
      } 
    } 
  },
  { $group: {
      _id: { 
        device: "$device_id", 
        hour: { $hour: "$timestamp" } 
      },
      avgValue: { $avg: "$value" },
      minValue: { $min: "$value" },
      maxValue: { $max: "$value" }
    }
  },
  { $sort: { "_id.hour": 1 } }
])

🔄 Replikacja i wysoka dostępność

Replikacja w MongoDB zapewnia redundancję danych i wysoką dostępność. Podstawowa konfiguracja to zestaw replik (replica set).

Konfiguracja zestawu replik

  1. Utwórz katalogi danych dla każdej instancji:
mkdir -p /data/rs1 /data/rs2 /data/rs3
  1. Uruchom trzy instancje MongoDB z różnymi portami:
mongod --replSet myrs --dbpath /data/rs1 --port 27017 --bind_ip localhost
mongod --replSet myrs --dbpath /data/rs2 --port 27018 --bind_ip localhost
mongod --replSet myrs --dbpath /data/rs3 --port 27019 --bind_ip localhost
  1. Zainicjuj zestaw replik:
// Podłącz się do pierwszej instancji
mongosh --port 27017

// Konfiguracja i inicjalizacja
rs.initiate({
  _id: "myrs",
  members: [
    { _id: 0, host: "localhost:27017" },
    { _id: 1, host: "localhost:27018" },
    { _id: 2, host: "localhost:27019" }
  ]
})

// Sprawdź status zestawu replik
rs.status()

Praca z zestawem replik

// Sprawdzenie roli bieżącego węzła
db.isMaster()

// Ustawienie preferencji zapisu
db.products.insertOne(
  { name: "Test" },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
)

// Ustawienie preferencji odczytu
db.products.find().readPref("secondaryPreferred")

🧩 Sharding (fragmentacja)

Sharding to technika partycjonowania danych między wieloma serwerami, pozwalająca na poziomą skalowalność.

Podstawowa architektura shardingu

  1. Shard - przechowuje podzbiór danych
  2. Config Server - przechowuje metadane klastra
  3. Mongos - router zapytań

Konfiguracja shardingu wymaga:

  1. Uruchomienia zestawu replik dla config serwerów
  2. Uruchomienia zestawu replik dla każdego sharda
  3. Uruchomienia mongos
  4. Włączenia shardingu dla bazy danych
  5. Wybrania klucza shardingu dla kolekcji
// Włączenie shardingu dla bazy danych
sh.enableSharding("my_database")

// Ustanowienie klucza shardingu dla kolekcji
sh.shardCollection(
  "my_database.products",
  { category: 1, _id: 1 }  // Klucz shardingu
)

// Sprawdzenie statusu shardingu
sh.status()

🛡️ Bezpieczeństwo i kopie zapasowe

Zabezpieczenie MongoDB

Kilka kluczowych praktyk bezpieczeństwa:

  1. Włącz autoryzację i używaj silnych haseł

  2. Kontrola dostępu oparta na rolach (RBAC):

// Tworzenie roli z ograniczonymi uprawnieniami
db.createRole({
  role: "readWriteProducts",
  privileges: [
    {
      resource: { db: "ecommerce", collection: "products" },
      actions: [ "find", "insert", "update", "remove" ]
    }
  ],
  roles: []
})

// Tworzenie użytkownika z tą rolą
db.createUser({
  user: "productManager",
  pwd: "secure_password",
  roles: [ { role: "readWriteProducts", db: "ecommerce" } ]
})
  1. Szyfrowanie danych:
  • Szyfrowanie danych w spoczynku (Enterprise Edition)
  • Konfiguracja TLS/SSL dla danych w ruchu
  1. Konfiguracja firewalla - ogranicz dostęp do portów MongoDB

Tworzenie kopii zapasowych

Używanie mongodump i mongorestore

# Utworzenie kopii
mongodump --host=localhost --port=27017 --out=/backup/2023-05-01

# Przywrócenie kopii
mongorestore --host=localhost --port=27017 /backup/2023-05-01

Używanie wbudowanych narzędzi replikacji

Utrzymuj zawsze aktualną replikę jako część strategii kopii zapasowych.

🌟 MongoDB Atlas i narzędzia

MongoDB Atlas

MongoDB Atlas to usługa DBaaS (Database as a Service) oferująca hostowanie MongoDB w chmurze.

Kluczowe funkcje:

  • Automatyczne skalowanie
  • Tworzenie kopii zapasowych
  • Monitorowanie i alerty
  • Globalna dystrybucja danych
  • Wbudowane zabezpieczenia

Narzędzia do pracy z MongoDB

  1. MongoDB Compass - graficzne narzędzie do eksploracji danych, wykonywania zapytań i wizualizacji

  2. MongoDB Shell (mongosh) - zaawansowany interaktywny interfejs wiersza poleceń

  3. MongoDB Database Tools - narzędzia wiersza poleceń do importu/eksportu, kopii zapasowych itp.

  4. MongoDB Charts - tworzenie wizualizacji i dashboardów

  5. MongoDB Realm - platforma do tworzenia aplikacji backendowych

📚 Integracja z językami programowania

Node.js

const { MongoClient } = require('mongodb');

async function connectToMongoDB() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("my_database");
    const collection = database.collection("products");

    // Wykonanie zapytania
    const query = { category: "electronics" };
    const products = await collection.find(query).toArray();
    console.log("Znalezione produkty:", products);

  } finally {
    await client.close();
  }
}

connectToMongoDB().catch(console.error);

Python

from pymongo import MongoClient

# Połączenie z bazą danych
client = MongoClient('mongodb://localhost:27017/')
db = client['my_database']
collection = db['products']

# Wstawienie dokumentu
product = {
    "name": "Laptop X1",
    "price": 4500,
    "category": "electronics",
    "inStock": True
}
result = collection.insert_one(product)
print(f"Inserted ID: {result.inserted_id}")

# Wyszukiwanie dokumentów
query = {"category": "electronics", "price": {"$lt": 5000}}
for product in collection.find(query).sort("price", 1):
    print(f"{product['name']}: {product['price']} zł")

client.close()

Java

import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoCollection;
import org.bson.Document;

public class MongoDBExample {
    public static void main(String[] args) {
        try (MongoClient client = MongoClients.create("mongodb://localhost:27017")) {
            MongoDatabase database = client.getDatabase("my_database");
            MongoCollection<Document> collection = database.getCollection("products");

            // Wstawienie dokumentu
            Document product = new Document("name", "Laptop X1")
                .append("price", 4500)
                .append("category", "electronics")
                .append("inStock", true);

            collection.insertOne(product);
            System.out.println("Document inserted!");

            // Wyszukiwanie dokumentów
            Document query = new Document("category", "electronics")
                .append("price", new Document("$lt", 5000));

            collection.find(query).forEach(doc -> {
                System.out.println(doc.getString("name") + ": " + doc.getInteger("price") + " zł");
            });
        }
    }
}

🏁 Podsumowanie - MongoDB dla nowoczesnych aplikacji

Gratulacje! Po przeczytaniu tego przewodnika posiadasz już solidną wiedzę na temat MongoDB - od podstawowych koncepcji, przez operacje CRUD, po zaawansowane techniki optymalizacji i skalowania. Podsumujmy najważniejsze punkty:

  1. MongoDB to elastyczna baza danych NoSQL, która przechowuje dane w dokumentach podobnych do JSON.
  2. Świetnie sprawdza się w aplikacjach z dynamiczną strukturą danych, systemach zarządzania treścią i aplikacjach czasu rzeczywistego.
  3. Oferuje bogaty zestaw narzędzi do zapytań, w tym zaawansowane operatory i framework agregacji.
  4. Zapewnia wysoką wydajność i skalowalność dzięki indeksom, replikacji i shardingowi.
  5. Posiada rozbudowany ekosystem narzędzi i usług, w tym MongoDB Atlas, Compass i Realm.

MongoDB rewolucjonizuje sposób, w jaki pracujemy z danymi, oferując wydajność, elastyczność i skalowalność niezbędne w nowoczesnych aplikacjach.

🚀 Potrzebujesz niezawodnego hostingu dla swoich baz danych MongoDB?

Sprawdź ofertę serwerów VPS w IQHost

Nasze serwery VPS oferują idealne środowisko do uruchamiania baz danych MongoDB - wysoką wydajność, elastyczność konfiguracji i niezawodność niezbędną dla krytycznych zastosowań.

❓ FAQ - Odpowiedzi na Twoje Pytania

Czy MongoDB jest darmowy?
Tak, MongoDB Community Edition jest w pełni darmowy i open-source. Wersja Enterprise z dodatkowymi funkcjami, takimi jak LDAP i Kerberos, oraz usługa MongoDB Atlas w chmurze mają płatne plany.

Kiedy powinienem wybrać MongoDB zamiast bazy SQL?
MongoDB jest dobrym wyborem, gdy twoja aplikacja wymaga elastycznego schematu, pracuje z dużymi wolumenami danych, potrzebuje wysokiej skalowalności lub operuje na złożonych, hierarchicznych strukturach danych. Bazy SQL są lepsze dla aplikacji z silnymi relacjami między danymi i wymagających transakcji ACID.

Czy MongoDB obsługuje transakcje?
Tak, od wersji 4.0 MongoDB obsługuje transakcje wielu dokumentów. Jednak warto pamiętać, że transakcje w MongoDB mają większy narzut wydajnościowy niż operacje na pojedynczych dokumentach, dlatego zaleca się projektowanie modelu danych tak, aby minimalizować potrzebę transakcji.

Jaka jest maksymalna wielkość dokumentu w MongoDB?
Maksymalny rozmiar dokumentu BSON w MongoDB to 16 MB. Dla większych danych można użyć GridFS, który automatycznie dzieli pliki na małe fragmenty.

Jak zabezpieczyć MongoDB przed nieautoryzowanym dostępem?
Kluczowe praktyki bezpieczeństwa to: włączenie autoryzacji, używanie silnych haseł, konfiguracja kontroli dostępu opartej na rolach (RBAC), uruchamianie MongoDB za firewallem, konfiguracja TLS/SSL dla komunikacji sieciowej i regularne aktualizacje do najnowszych wersji.

Kategorie i tagi

Bazy Danych Programowanie

Czy ten artykuł był pomocny?

Wróć do listy wpisów

Twoja strona WordPress działa wolno?

Sprawdź nasz hosting WordPress z ultraszybkimi dyskami NVMe i konfiguracją serwera zoptymalizowaną pod kątem wydajności. Doświadcz różnicy już dziś!

Sprawdź ofertę hostingu
30-dniowa gwarancja zwrotu pieniędzy