Implementació de Hash-Based Sharding usant MongoDB i Docker

Introducció

El sharding és una tècnica de particionament horitzontal utilitzada per distribuir dades entre múltiples servidors MongoDB.

Permet:

• escalar horitzontalment,
• distribuir càrrega,
• millorar el rendiment,
• augmentar la disponibilitat.

MongoDB implementa sharding de forma nativa mitjançant clusters distribuïts.

Tipus de sharding

Range-based sharding

Les dades es distribueixen per rangs de valors.

Exemple:

• ID 1-1000 → shard1
• ID 1001-2000 → shard2

Aquest sistema pot generar hotspots si moltes escriptures es concentren en un mateix rang.

Hash-based sharding

S'aplica una funció hash sobre la Shard Key.

Avantatges:

• distribució uniforme,
• balanceig automàtic,
• evita hotspots.

És l’estratègia recomanada per càrregues generals.

List-based sharding

Les dades es reparteixen segons valors predefinits.

Exemple:

• Espanya → shard1
• França → shard2

Components d’un cluster MongoDB

Arquitectura

                +----------------+
                |     Mongos     |
                +--------+-------+
                         |
        +----------------+----------------+
        |                                 |
   +----+----+                       +----+----+
   |  Shard1 |                       |  Shard2 |
   +---------+                       +---------+

              +------------------+
              |  Config Server   |
              +------------------+

Exemple pràctic sobre Fedora Linux

Crear directori de treball

mkdir /mongodb-sharding
cd /mongodb-sharding

Crear el Docker Compose

Crear el fitxer docker-compose.yml:

version: "3.8"

services:

  configsvr:
    container_name: configsvr
    image: mongo:4.4
    restart: always
    command: >
      mongod --configsvr --replSet configReplSet --port 27019 --bind_ip_all
    ports:
      - "27019:27019"
    volumes:
      - configdb:/data/db

  shard1:
    container_name: shard1
    image: mongo:4.4
    restart: always
    command: >
      mongod --shardsvr --replSet shard1ReplSet --port 27018 --bind_ip_all
    ports:
      - "27018:27018"
    volumes:
      - shard1db:/data/db

  shard2:
    container_name: shard2
    image: mongo:4.4
    restart: always
    command: >
      mongod --shardsvr --replSet shard2ReplSet --port 27018 --bind_ip_all
    ports:
      - "27028:27018"
    volumes:
      - shard2db:/data/db

  mongos:
    container_name: mongos
    image: mongo:4.4
    restart: always
    depends_on:
      - configsvr
      - shard1
      - shard2
    command: >
      mongos --configdb configReplSet/configsvr:27019 --bind_ip_all --port 27017
    ports:
      - "27017:27017"

volumes:
  configdb: {}
  shard1db: {}
  shard2db: {}

Persistència i reinici automàtic

S’utilitzen volums Docker per mantenir les dades persistents encara que els contenidors s’aturin o es recreïn.

Sense volums, la pèrdua dels contenidors implicaria la pèrdua de totes les dades del cluster.

També s’ha configurat:

restart: always

Aquesta directiva permet reiniciar automàticament els contenidors després d’un reinici del sistema o de la màquina.

Inicialitzar els contenidors

docker-compose up -d
docker ps

Inicialitzar el Config Server

docker exec -it configsvr mongo --port 27019

rs.initiate({
  _id: "configReplSet",
  configsvr: true,
  members: [
    { _id: 0, host: "configsvr:27019" }
  ]
})

Inicialitzar shard1

docker exec -it shard1 mongo --port 27018

rs.initiate({
  _id: "shard1ReplSet",
  members: [
    { _id: 0, host: "shard1:27018" }
  ]
})

Inicialitzar shard2

docker exec -it shard2 mongo --port 27018

rs.initiate({
  _id: "shard2ReplSet",
  members: [
    { _id: 0, host: "shard2:27018" }
  ]
})

Afegir shards al cluster

docker exec -it mongos mongo --port 27017

sh.addShard("shard1ReplSet/shard1:27018")
sh.addShard("shard2ReplSet/shard2:27018")

Activar sharding

sh.enableSharding("testDB")

Configurar la col·lecció

sh.shardCollection(
  "testDB.users",
  { _id: "hashed" }
)

Inserir dades

use testDB
 
for (let i = 0; i < 1000; i++) {
  db.users.insert({
    name: "user" + i,
    value: i
  })
}

Comprovar la distribució

db.users.getShardDistribution()

Consultar la configuració

use config
 
db.collections.find({
  _id: "testDB.users"
})

Conclusions

El sharding permet escalar MongoDB distribuint les dades entre múltiples nodes.

L’ús de hashed shard keys facilita:

• el balanceig automàtic,
• la distribució uniforme,
• la reducció de hotspots.