Deck utilizado para un taller dictado sobre mongodb (track administración y seguridad)

1. MongoDB
Instalación y administración
Juan Esteban Ladetto
jladetto@gmail.com

2. Instalación en diferentes ambientes
• Cómo todo proyecto Open Source (versiones pares son las estables)
• 2.4, 2.6 (2.5 es desarrollo de los features que tendrá la versión 2.6)
• En producción solamente las versiones pares y la última subversión
(2.6.7)
• Mongodb se puede descargar tanto binarios como código fuente y
compilar
• 32 bits o 64 bits y para cualquier plataforma

3. Instalación en windows
• www.mongodb.org/downloads
• Necesario dbpath (default: datadb)
• Puerto por defecto: 27017
• Instalar como servicio:
• "C:mongodbbinmongod.exe" --config "C:mongodbmongod.cfg" --install
• Eliminar como servicio
• mongod.exe --remove

4. Instalación en Linux (ubuntu)
- sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10
- echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | sudo tee
/etc/apt/sources.list.d/mongodb.list
- sudo apt-get update
- sudo apt-get install -y mongodb-org
mongodb-org
This package is a metapackage that will automatically install the
four component packages listed below.
mongodb-org-server
This package contains the mongod daemon and associated
configuration and init scripts.
mongodb-org-mongos
This package contains the mongos daemon.
mongodb-org-shell
This package contains the mongo shell.
mongodb-org-tools
This package contains the following MongoDB tools: mongoimport
bsondump, mongodump, mongoexport, mongofiles, mongooplog,
mongoperf, mongorestore, mongostat, and mongotop.

5. Parámetros de configuración
• http://docs.mongodb.org/manual/reference/configuration-options/

6. Comandos básicos del Shell de mongodb
• help Muestra ayuda
• db.help() Muestra ayuda para db
• db.<collection>.help() muestra ayuda para cualquier colección
• show dbs Muetra las dbs
• use <db> Cambia la db que se usa
• show collections Lista todas las colecciones de una db
• show users Muestra los usuarios de una db
• show roles Muestra los roles de la db
• show profile Muestra los queries que demoraron más de 1 milisegundo
• show databases = show dbs

7. Comandos básicos del Shell de mongodb
• db.cloneDatabase(<host>) Clona la db actual al host especificado,
el host no puede tener seguridad.
• db.copyDatabase(<from>, <to>, <host>) Copia la db <from> desde
el <host a la db que se especifique.
• db.fromColl.renameCollection(<toColl>) Renombra la co.
• db.repairDatabase() Repara y compacta la db. Es lento y bloquea la
db
• db.createUser( <user>, <pwd> ) Agrega un usuario a la db actual
• db.getCollectionNames() Lista las colecciones de la db actual.
• db.dropDatabase() borra la db actual.

8. Creación y administración de usuarios
• Por defecto no autorización ni autenticación
• 2 formas de habilitarlo
• Antes de iniciar servicio con auth
• Iniciar servicio con auth y aprovechar el localhost exception (no recomendado
para armar replicasets/sharing)

9. Authorization
• Si el servicio corre standalone habilitando el flag auth
• Si el servicio corre como parte de un replication set o un shard es
necesario un keyfile (compartido) como mínimo
• MongoDB soporta 2 mecanismos en su versión no paga: password base
(keyfile) y certificados x.509
openssl rand -base64 741 > mongodb-keyfile
chmod 600 mongodb-keyfile

10. Authentication
• Un usuario pertenece a una db y sobre estas puede tener todos los
roles que quiera
• Existen 2 bases de datos especiales en mongodb (admin y local) y los
usuarios de esas bases de datos pueden realizar operaciones en otras
bases de datos siempre y cuando se les den acceso
use admin
db.createUser(
{
user: “root",
pwd: "password",
roles: [ { role: "userAdminAnyDatabase", db:
"admin" } ]
}
)
use admin
db.createUser(
{
user: “god",
pwd: "password",
roles: [ “root”]
}
)
db.runCommand({rolesInfo: “god", showPrivileges: true});
db.runCommand({rolesInfo: { role: "dbAdmin", db: "blog" } , showPrivileges: true});

11. Roles
• A nivel de datos de bases de datos:
• read
• readWrite
• A nivel de administración de bases de datos:
• dbAdmin
• dbOwner
• userAdmin
• Lista completa de roles predefinidos:
http://docs.mongodb.org/manual/reference/built-in-roles/#built-in-roles
• Lista completa de las funciones que se pueden hacer con roles:
http://docs.mongodb.org/manual/reference/command/#role-management-
commands
db.createUser(
{
user: "accountUser",
pwd: "password",
roles: [ "readWrite", "dbAdmin" ]
}
)
db.runCommand({connectionStatus:1});
db.updateUser(“usuario”, doc)

12. Comandos útiles para creación y
manipulación de usuarios
db.createUser({
user: "siteUserAdmin",
pwd: "password",
roles: [ { role: "userAdminAnyDatabase", db: "admin"
} ] })
db.createUser({
user: "superuser",
pwd: "12345678",
roles: [ "root" ]})
db.updateUser("user123",{
pwd: "KNlZmiaNUp0B",
customData: { title: "Senior Manager" }})
db.changeUserPassword("reporting",
"SOh3TbYhxuLiW8ypJPxmt1oOfL")
db.getUser(“”)
db.getRole( "readWrite", { showPrivileges: true } )
db.grantRolesToUser(
"reportsUser",
[{ role: "readWrite", db: "products" } ,
{ role: "readAnyDatabase", db:"admin" }])
db.revokeRolesFromUser(
"reportsUser",
[{ role: "readWrite", db: "accounts" }]
)
db.createRole({
role: "manageOpRole",
privileges: [{ resource: { cluster: true }, actions: [ "killop",
"inprog" ] },
{ resource: { db: "", collection: "" }, actions: [
"killCursors" ] }],
roles: []})

13. Conceptos a conocer de mongodb
Memory Mapped Files
• Todos los archivos de datos son memory mapped a la memoria virtual
del OS
• MongoDB lee y escribe en RAM y el filesystem hace el resto
• Virtual Process size: suma de los tamaños de los arhivos + overhead
(heap, conexiones)
• Si el journal está activo el tamaño de la memoria virtual será casi el
doble

14. Conceptos a conocer de mongodb
Journal
• Los cambios en los archivos mapeados en memoria no se aplican en
orden y diferentes partes de un archivo pueden ser de diferentes
momentos
• Si algo sucedió y mongodb se cierra inesperadamente queremos
volver a tener un estado consistente.

15. Conceptos a conocer de mongodb
Archivos
drwxr-xr-x 136 Nov 19 10:12 journal
-rw------- 16777216 Oct 25 14:58 test.0
-rw------- 134217728 Oct 25 14:58 test.1
-rw------- 268435456 Oct 25 14:58 test.2
-rw------- 536870912 Oct 25 14:58 test.3
-rw------- 1073741824 Oct 25 14:58 test.4
-rw------- 2146435072 Oct 25 14:58 test.5
-rw------- 16777216 Oct 25 14:58 test.ns

16. Conceptos a conocer de mongodb
Archivos
drwxr-xr-x 136 Nov 19 10:12 journal
-rw------- 16777216 Oct 25 14:58 test.0
-rw------- 134217728 Oct 25 14:58 test.1
-rw------- 268435456 Oct 25 14:58 test.2
-rw------- 536870912 Oct 25 14:58 test.3
-rw------- 1073741824 Oct 25 14:58 test.4
-rw------- 2146435072 Oct 25 14:58 test.5
-rw------- 16777216 Oct 25 14:58 test.ns
--directoryperdb
--smallfiles
–nopreallocate para muchas base de datos

17. Conceptos a conocer de mongodb
Indices

18. Conceptos a conocer de mongodb
Stats > db.Sessions.stats(){
"ns" : "SessionState.Sessions",
"count" : 2720,
"size" : 16509440,
"avgObjSize" : 6069,
"storageSize" : 58408960,
"numExtents" : 8,
"nindexes" : 2,
"lastExtentSize" : 20643840,
"paddingFactor" : 1,
"systemFlags" : 1,
"userFlags" : 1,
"totalIndexSize" : 351568,
"indexSizes" : {"_id_" : 212576,"Expires_1" : 138992},
"ok" : 1}
> db.stats(){
"db" : "SessionState",
"collections" : 4,
"objects" : 3504,
"avgObjSize" : 4996.649543378995,
"dataSize" : 17508260,
"storageSize" : 59473920,
"numExtents" : 11,
"indexes" : 2,
"indexSize" : 351568,
"fileSize" : 67108864,
"nsSizeMB" : 16,
"dataFileVersion" : {"major" : 4, "minor" : 5},
"extentFreeList" : {"num" : 0,"totalSize" : 0},
"ok" : 1}

19. Replica Sets

20. Replica Set – Initialize

21. Replica Set – Failure

22. Replica Set – Failover

23. Replica Set – Recovery

24. Replica Set – Recovered

25. > conf = {
_id : "mySet",
members : [
{_id : 0, host : “host:20717”, priority : 3},
{_id : 1, host : “host:27018", priority : 2},
{_id : 2, host : “host:27019”},
{_id : 4, host : "E", hidden : true, slaveDelay : 3600}
]
}
> rs.initiate(conf)
Configuration Options
> conf = {
_id : "mySet",
members : [“host:20717”,
“host:27018", “host:27019”],
{_id : 4, host : "E", hidden : true, slaveDelay
}
> rs.initiate(conf)

26. Desarrollando con replica sets
Alta consistencia de datos

27. Desarrollando con replica sets
Baja consistencia de datos

28. Write Concern
• Network acknowledgement
• Wait for error
• Wait for journal sync
• Wait for replication

29. Unacknowledged

30. MongoDB Acknowledged (wait for error)

31. Wait for Journal Sync

32. Wait for Replication

33. Tagging
• Controla desde donde y hacia donde leer y escribir
• Cada miembro puede tener uno o más tags
• tags: {dc: "ny"}
• tags: {dc: "ny", subnet: "192.168", rack: "row3rk7"}
• Replica Sets definen las reglas de write concern
• Las reglas pueden cambiar sin afectar el desarrollo ya realizado

34. Un ejemplo
• {
• _id : "mySet",
• members : [
• {_id : 0, host : "A", tags : {"dc": "ny"}},
• {_id : 1, host : "B", tags : {"dc": "ny"}},
• {_id : 2, host : "C", tags : {"dc": "sf"}},
• {_id : 3, host : "D", tags : {"dc": "sf"}},
• {_id : 4, host : "E", tags : {"dc": "cloud"}}],
• settings : {
• getLastErrorModes : {
• allDCs : {"dc" : 3},
• someDCs : {"dc" : 2}} }
• }
• > db.blogs.insert({...})
• > db.runCommand({getLastError : 1, w : "someDCs"})

35. Wait for Replication (Tagging)

36. Modos de lectura
• 5 modes
• primary (only) - Default
• primaryPreferred
• secondary
• secondaryPreferred
• Nearest
Cuando más de un nodo es posible de elegir el más cercano es el usado

37. Mantenimiento y upgrade
• No downtime
• Hacer mantenimiento/upgrade
– Empezar con los nodos secundarios
– Dejar para el final de primario

38. Replica Set – 1 Data Center
Single datacenter
Puntos de falla:
– Power
– Network
– Data center
– Que fallen 2 nodos

39. Replica Set – 2 Data Centers
Multi data center
Un nodo en otro DC
No es posible durabilidad
ya que si se cae el DC1
no podrá hacerse como
primary (falta al menos 1
member más)

40. Replica Set – 3 Data Centers
3 data centers

41. Cómo funciona internamente
• Heartbeat cada 2 segundos
• Times-out en 10 segundos
• Local DB (not replicated)
– system.replset
– oplog.rs
• Capped collection donde se almacenan las
operaciones realizadas en el nodo

42. Replica Set commands
• rs.initiate(config) -> inicializa la replicaset
• Config=> doc con members
• rs.status() -> status
• rs.isMaster() -> devuelve info de quien es master
• rs.config()
• rs.reconfig(config)
• rs.add( { "_id": 3, "host": "mongodbd3.example.net:27017", "priority": 0 } )
• rs.stepDown()
• rs.freeze() -> no elegirme como primario por x n segundos
• rs.remove()
• rs.slaveOk()
• db.isMaster()
• rs.syncFrom()

43. Sharding

44. Vertical Scalability (Scale Up)

45. Horizontal Scalability (Scale Out)

46. Particionado
• Los usuarios definen el shard key
• Los shard keys definen un rango de datos
• Los keys son como puntos en una línea
• El rango es un segment de esa línea

47. Distribución de la información
• Inicialmente 1 chunk (64mb)
• MongoDB automáticamente divide y migra los chunks when el
máximo es alcanzado

48. Balanceo y ruteo
• Las consultas rutean a los shards específicos
• MongoDB balancea el cluster
• MongoDB migra automáticamente a nuevos nodos

49. Architecture
• Juguemos con un sharding de prueba
mongo –nodb
cluster = new ShardingTest({"shards" : 3, "chunksize" : 1})
db = (new Mongo("localhost:30999")).getDB("test")
for (var i=0; i<100000; i++) {
db.users.insert({"username" : "user"+i, "created_at" : new Date()});
}
db.users.count()
sh.status()
sh.enableSharding("test")
db.users.ensureIndex({"username" : 1})
sh.shardCollection("test.users", {"username" : 1})
db.users.find({username: "user12345"}).explain()
db.users.find().explain()
cluster.stop()

50. Qué es un shard?
• Shard es un nodo del cluster
• Un shard puede ser un simple mongod o una replica set

51. Meta Data Storage
• Config servers
• Almacena cluster chunk ranges and locations
• O 1 o 3 (en producción tienen que ser 3)
• No son replica sets (almacenan lo mismo por separado)

52. Routing y balanceo
• Mongos
• Actúan como routers/balanceadores
• No tienen información local (persiste la info en los config servers)
• Puede ser como mínimo uno o más (pueden correr en los mismos
server que los config servers)

53. infrastructura Sharding

54. Iniciar un servidor de configuración
• mongod –configsvr default port (27019)

55. mongos Router
• mongos --configdb <hostname>:27019
• Para 3 servidores de configuración
mongos --configdb <host1>:<port1>,<host2>:<port2>,<host3>:<port3>
• Siempre se puede agregar un nuevo mongos por más que el cluster esté andando

56. Arrancar un shard
• mongod --shardsvr
• Arranca un mongod con el
Puerto por defecto (27018)
• Shard no es parte del
cluster
• Shard puede haber corrido
en producción

57. Agregar el Shard
• On mongos:
• sh.addShard(‘<host>:27018’)
• Adding a replica set:
• sh.addShard(‘<host>:<port>’) de un
nodo del replica set

58. Verificar que un shard se haya agregado
db.runCommand({ listshards:1 })

59. Habilitar Sharding
sh.enableSharding(“<dbname>”)
sh.shardCollection(“<dbname>.people”,{“country”:1})
sh.shardCollection(“<dbname>.cars”,{“year”:1, ”uniqueid”:1}) -> key
compuesto para evitar duplicados

60. Chunk es una sección de un rango más
grande

61. Separando Chunks
• Un chunk es dividido solamente cuando exceed su máximo tamaño
• Si los shard key tienen el mismo valor no se pueden dividir
• La division de un Chunk es una operación lógica (no hay movimiento
de información)

62. Balanceo
• Mongos corren los balanceos
• Cuando la diferencias de chunks entre los shards más densos y los
menos densos llega al punto máximo comienza la migración

63. Ronda de balanceo
• Un mongos toma el Balancer lock
• Status
use config
db.locks.find(
{ _id: “balancer” })

64. Mover chunks
• Mongos envía un moveChunk al shard de origen
• El shard de origen notifica al shard de destino
• El shard de destino toma el documento desde el origen

65. Listo, documento en Nuevo shard
• El shard de destino actualiza el servidor de configuración

66. Ruteo de consultas: Consultas puntuales

67. Ruteo de consultas: Consultas puntuales
recibimos pedido

68. Ruteo de consultas: Consultas puntuales
Sabemos donde está la info

69. Ruteo de consultas: Consultas puntuales
el shard devuelve lo solicitado

70. Mongos devuelve la info al cliente

71. Ruteo de queries más complejas (mapping)

72. Consulta compleja recibida

73. Enviamos el pedido a todos los shards

74. Devuelven la info que solicitamos

75. Mongos devuelve al cliente

76. Mismo caso con sort

77. Shard Key
• Shard key es immutable
• Los valores de los Shard key son immutables
• Tienen que estar indexados
• Shard key limitado a 512 bytes
• Shard key usado como route query
• Elegir un campo comunmente usado en consultas

78. Consideraciones
• Cardinalidad
• Distribución de escritura
• Query Isolation
• Disponibilidad
• Localidad de los índices
Optimizar el ruteo
Minimizar tráfico innecesario
Permitir el mejor escalamiento

79. Métodos de Backup
• 3 posibilidades:
• LVM snapshots
• mongodump -> mongorestore
• MMS backup service

80. Métodos de Backup
LVM snapshots
• Consiste en hacer un snapshot de todo el volumen donde está
montada la db
• La base de datos debe estar en un estado válido al momento del snapshot
• Si hay documentos que se están escribiendo puede quedar en un estado
inconsistente
• Si se usa journaling el journal tiene que residir en el mismo volumen
• No se puede capturar el backup incremental

81. Métodos de Backup
mongodump-mongorestore
• Para poder hacer un dump el usuario como mínimo rol de backup o
dbAdmin
• Algunos parámetros necesarios
• mongodump –u <usuario> -p <pwd> --authenticationDatabase <db> --host
<host><:port> -d <database> -c <collection> -o <path> --oplog --journal
• Para hacer restore el procedimiento es similar
• mongorestore –u <usuario> -p <pwd> --authenticationDatabase <db> --host
<host><:port> -d <database> -c <collection> -o <path> --oplogReplay –oplogLimit
<timestamp>

82. mongodump
• options:
• --help produce help message
• -v [ --verbose ] be more verbose (include multiple times for more verbosity e.g. -vvvvv)
• -h [ --host ] arg mongo host to connect to ( <set name>/s1,s2 for sets)
• --port arg server port. Can also use --host hostname:port
• --ipv6 enable IPv6 support (disabled by default)
• -u [ --username ] arg username
• -p [ --password ] arg password
• --dbpath arg directly access mongod database files in the given path, instead of connecting to a mongod server - needs to lock the data directory, so cannot be used if a
mongod is currently accessing the same path
• --directoryperdb if dbpath specified, each db is in a separate directory
• -d [ --db ] arg database to use
• -c [ --collection ] arg collection to use (some commands)
• -o [ --out ] arg (=dump) output directory or "-" for stdout
• -q [ --query ] arg json query
• --oplog Use oplog for point-in-time snapshotting
• --repair try to recover a crashed database

83. mongorestore
options:
--help produce help message
-v [ --verbose ] be more verbose (include multiple times for more verbosity e.g. -vvvvv)
-h [ --host ] arg mongo host to connect to ( <set name>/s1,s2 for sets)
--port arg server port. Can also use --host hostname:port
--ipv6 enable IPv6 support (disabled by default)
-u [ --username ] arg username
-p [ --password ] arg password
--dbpath arg directly access mongod database files in the given path, instead of connecting to a mongod server - needs to lock the data directory, so cannot be used if a
mongod is currently accessing the same path
--directoryperdb if dbpath specified, each db is in a separate directory
-d [ --db ] arg database to use
-c [ --collection ] arg collection to use (some commands)
--objcheck validate object before inserting
--filter arg filter to apply before inserting
--drop drop each collection before import
--oplogReplay replay oplog for point-in-time restore

84. Métodos de Backup
MMS backup service
• Servicio hosteado por la gente de 10gen (mongodb)
• Incremental backup

85. Métodos de Backup
Incremental backups
• https://github.com/EqualExperts/Tayra/
• https://github.com/reverb/wordnik-oss
• MMS 

86. Importando y exportando collecciones
mongoimport --host localhost --db myDB --collection myCollection --
type csv --file data.csv --headerline –upsert
mongoexport --host localhost --db myDB --collection myCollection --
csv –out data.csv

87. Algunas otras cosas
• Capped Collections
• db.createCollection( "log", { capped: true, size: 100000 , max:1000} )
• db.collection.isCapped()
• db.runCommand({"convertToCapped": "mycoll", size: 100000});
• Ttl collections
• db.log_events.ensureIndex( { "createdAt": 1 }, { expireAfterSeconds: 3600 } )

88. Notas para llegar a producción
• Redes
• Connection pooling
• db.runCommand({ connPoolStats: 1 } )
• Hardware
• SSD cuando sea posible
• CPU y suficiente RAM para manejar el volumen o carga
• Disco
• Obviar NFS cuando sea posible
• Separar journals/databases en diferentes volúmenes
• ReplicaSet o Sharding
• Definir el nivel de Write concern que se requiera

89. Seguridad
Exposición en redes y seguridad
- wire protocol
- bind_ip: intentar que la exposición sea únicamente hacia adentro
- port: si bien el 27017 es el default de mongo no viene mal cambiarlo
- desde que redes pueden llegar? Filtremos lo más posible

90. Seguridad
Checklist de seguridad
• Siempre con authorization y authentication
• Collection-level Access control
• db.createRole( {
role: "collectionInventario",
privileges: [ { resource: { db: "products", collection: "inventory" },
actions: [ "find", "update", "insert" ] },
{ resource: { db: "products", collection: "orders" },
actions: [ "find" ] } ] , roles: [] })
db.grantRolesToUser( "usuario", [ "collectionInventario" ] )
db.getUser(“usuario”)
• http://docs.mongodb.org/v2.6/MongoDB-security-guide.pdf

91. Monitoreo
Qué y con qué?
• Working sets
• db.stats()
• db.runCommand( { serverStatus: 1, workingSet: 1 } )
• Oplog replication lag
• rs.printSlaveReplicationInfo()
• IOPS
• Cantidad de conexiones
• db.runCommand ({connPoolStats: 1})
• Disponibilidad en el storage
• Memoria
• Uso de CPU (+70% empezamos a complicarnos, queries no optimizadas, etc)
• Capacidad de redes/Traffic IN/OUT
• Pages faults
• db.adminCommand({"serverStatus" : 1}).recordStats -> cantidad de veces que tuvimos que hace
swap de páginas

92. Monitoreo
Qué y con qué?
• iostat
• vmstat
• mongotop
• mongostat
• mongoperf echo “{nTheards:12, fileSizeMB:1024, r:true}” | mongoperf
• Mirar las slow queries (
• db.setProfilingLevel(1, 100)
• db.system.profile.find().limit(10).sort( { ts : -1 } ).pretty()
• Mucho mejor con - http://mongolab.org/dex/

93. Monitoreo
Herramientas de monitoreo
Integrando con otras herramientas
Tool Plugin Description
Ganglia mongodb-ganglia
Python script to report operations
per second, memory usage, btree
statistics, master/slave status and
current connections.
Ganglia gmond_python_modules
Parses output from the serverStatus
and replSetGetStatus commands.
Motop None
Realtime monitoring tool for
MongoDB servers. Shows current
operations ordered by durations
every second.
mtop None A top like tool.
Munin mongo-munin Retrieves server statistics.
Munin mongomon
Retrieves collection statistics (sizes,
index sizes, and each (configured)
collection count for one DB).
Munin munin-plugins Ubuntu PPA
Some additional munin plugins not in
the main distribution.
Nagios nagios-plugin-mongodb
A simple Nagios check script, written
in Python.
Zabbix mikoomi-mongodb
Monitors availability, resource
utilization, health, performance and
other important metrics.
http://docs.mongodb.org/manual/administration/monitoring/#self-hosted-monitoring-tools

94. Operando mongodb
• db.currentOp() – o filtrar por cualquier parte del documento
• db.killOp()
• db.system.profile.find().pretty()

95. Complementos
• Herramientas varias para trabajar con mongodb
• Rockmongo
• MMS overview

96. Disaster recovery
• Procedimientos y prácticas

97. Consideraciones finales
• Procedimientos y prácticas

98. Preguntas?
Gracias
Juan Esteban Ladetto
jladetto@gmail.com