你的位置:首页 > 数据库类

MongoDB入门学习(一)

2014-05-04 浏览:(6109) 数据库类 评论(0)

一、启动mongodb

通过mongod启动mongodb服务

1、mongod参数选项

[root@primary bin]# ./mongod –help

-h [ --help ]         帮助信息
--version             版本信息
-f [ --config ] arg   配置文件选项
-v [ --verbose ]      提高内部报告标准输出或记录到logpath配置的日志文件中
--port                指定服务端口(默认27017)
--auth                启用验证
--noauthrun           不启用验证
--nohttpinterface     关闭http接口,默认关闭27018端口访问
--fork                以守护进程的方式运行MongoDB,创建服务器进程(后台运行)
--bind_ip             绑定服务IP,若绑定127.0.0.1,则只能本机访问(默认本地所有IP)
--maxConns            最大同时连接数 默认2000
--logpath             指定MongoDB日志文件,注意是指定文件不是目录
--logappend           使用追加的方式写日志
--pidfilepath         PID File 的完整路径,如果没有设置,则没有PID文件(pidfilepath=/path/mongod.pid )
--keyFile             集群的私钥的完整路径,只对于Replica Set 架构有效
--setParameter        设置参数(mongod --setParameter textSearchEnabled=true)
--nounixsocket        关闭unix socket 监听
--unixSocketPrefix    UNIX域套接字替代目录,(默认为 /tmp)
--sysloglog           
--cpu                 定期显示CPU的CPU利用率和iowait
--dbpath              指定数据库路径(默认/data/db/)
--diaglog             选项 0=off 1=W 2=R 3=both 7=W+some reads
--directoryperdbeach  数据库将存储在一个单独的目录中
--ipv6                IPV6(默认关闭)
--journal             启用日志选项,MongoDB的数据操作将会写入到journal文件夹的文件里
--journalCommitInterval buffer刷新到JournalFile的时间间隔
--journalOptions      启用日志诊断选项
--jsonp               允许JSONP形式通过HTTP访问(有安全影响) 
--nojournal           禁用日志选项
--noprealloc          不预先分配存储
--noscripting         禁用脚本引擎
--notablescan         不允许表扫描
--nssize arg (=16)    设置信数据库.ns文件大小(MB)
--profile             档案参数 0=off 1=slow, 2=all
--quota               将每个数据库限制到一定数量的文件(8个默认值)
--quotaFiles          #argnumber of files allowed per db, requires --quota
--repair              #修复所有db
--repairpath          指定修复文件路径(defaults to dbpath)
--rest                开启restful http interface,默认是关闭的(控制restful查询接口)
--shutdown            关闭服务器进程{db.shutdownServer();}
--slowms arg (=100)   #value of slow for profile and console log
--smallfilesuse a     #smaller default file size
--syncdelay arg (=60) 数据写入磁盘的时间秒数(0=never,不推荐)
--sysinfo             打印一些诊断系统信息
--upgrade             如果需要升级数据库
//复制选项:
--oplogSize arg       设置oplog的大小(MB). default is 5% of disk space 
主/从参数:
--master              master mode
--slave               slave mode
--source              从节点指定主节点的IP和端口 <server:port>
--only arg            从库指定单一的数据库复制
--slavedelay          设置从库同步主库的延迟时间
--autoresync          如果从库与主库同步数据差得多,自动重新同步
Replica set(副本集)选项:
--replSet arg         设置副本集名称,格式 <setname>[/<optionalseedhostlist>]
--replIndexPrefetch   默认all,secondary副本集的成员将加载所有索引到内存中或只会加载_id索引[none|_id_only|all]
分片选项:
--configsvr           声明这是一个集群的config服务,默认端口27019,默认目录/data/configdb
--shardsvrdeclare     this is a shard db of a cluster; default port 27018

2、mongod启动服务

/mongodb/mongodb/bin/mongod --dbpath=/mongodb/mongodb/bin/db
/mongodb/mongodb/bin/mongod --dbpath=/mongodb/mongodb/bin/db --rest --port=27017 --fork
说明:
默认端口:27017 
web控制台端口:27017+1000=28017
http://localhost:28017

3、参数使用

--config  将配置放到config文件。
创建:
mkdir -p /mongodb/mongodb/config/
mkdir -p /mongodb/mongodb/config/db
cp mongod /mongodb/mongodb/config/
vi c.config
port=27018
dbpath=/mongodb/mongodb/config/db
启动
mongod --config=/mongodb/mongodb/config/c.config
登录:
mongo 127.0.0.1:27018

二、关闭mongodb

> use admin
switched to db admin
> db.shutdownServer()
Sun Sep  4 02:33:44.407 DBClientCursor::init call() failed
server should be down...
Sun Sep  4 02:33:44.408 trying reconnect to 127.0.0.1:27017
Sun Sep  4 02:33:44.408 reconnect 127.0.0.1:27017 failed couldn't connect to server 127.0.0.1:27017
>

三、client访问mongodb

1、mongo参数选项

[root@primary bin]# ./mongo --help
MongoDB shell version: 2.4.9
usage: ./mongo [options] [db address] [file names (ending in .js)]
db address can be:
foo   
192.169.0.5/foo   
192.169.0.5:9999/foo
选项:
--shell                   从命令行运行完一个 .js 文件后,停留在shell中,而不是结束
--nodb                    不连接数据库方式启动,稍后可以使用 new Mongo() 或 connect() 来建立连接
--quiet                   安静输出
--port                    连接端口
--host                    连接主机
--eval                    #mongo admin --eval "mongo shell指令“
-u                        认证用户
-p                        认证密码
--authenticationDatabase  //>mongo --authenticationDatabase admin -u testuser -p 
--authenticationMechanism //(=MONGODB-CR)
-h [ --help ]             帮助信息
--version                 //show version information
--verbose                 -v详细模式,多个v可以增加详细输出,如-vvvv
--ipv6enable              //IPv6 support (disabled by default)

2、启动例子

/mongodb/bin/mongo 127.0.0.1:27017
[root@primary bin]# /mongodb/bin/mongo 127.0.0.1:27017/zxq -u zxq -p 1234
MongoDB shell version: 2.4.9
connecting to: 127.0.0.1:27017/zxq
> 
> show collections
aaa
ddd
system.indexes
system.users
t1
zxq
zxq123
>

四、用户认证

开启安全认证之前,需要有一个管理员用户(admin数据库中的用户为超级管理员)

1、进入admin数据库中,分配用户

use admin
db.help()
> db.addUser("root","1234")
{
        "user" : "root",
        "readOnly" : false,
        "pwd" : "fa0450e8c3e5fff6005de2f88559c3d9",
        "_id" : ObjectId("57a4f53cda8f119aa039cf34")
}

2、进入用户数据库,分配用户

use zxq
db.addUser("zxq","1234")
db.addUser("zxqread","1234",true) //只读用户

> db.addUser("zxq","1234")
{
        "user" : "zxq",
        "readOnly" : false,
        "pwd" : "3e7c9de5121b9c6b4c6c289b9c61c8f3",
        "_id" : ObjectId("57a4f607da8f119aa039cf35")
}

3、服务端开启安全检查

停止服务,并安全检查方式启动服务
mongod --dbpath=./db --port=27017 --auth

4、客户端连接,此时需要认证

[root@primary bin]# ./mongo 127.0.0.1:27017/zxq
MongoDB shell version: 2.4.9
connecting to: 127.0.0.1:27017/zxq
> show collectionsshow collections
Sat Aug  6 04:26:15.274 error: {
"$err" : "not authorized for query on zxq.system.namespaces",
"code" : 16550
} at src/mongo/shell/query.js:128
> 
此时认证失败
>use zxq
>
> db.auth("zxq","1234")
1
> db.auth("zxq","1234")
1

>use admin
> db.auth("root","1234")
1
> show collections
system.indexes
system.users
> 
认证方式通过,可以进行其它操作

5、客户端连接,此时需要认证

for:mongod dbname -u uname -p password
[root@primary bin]# ./mongo admin -u root -p 1234
MongoDB shell version: 2.4.9
connecting to: admin

[root@primary bin]# ./mongo zxq -u zxq -p 1234
MongoDB shell version: 2.4.9
connecting to: zxq

**//只读用户测试//**
[root@primary bin]# ./mongo zxq -u readonly -p 1234
MongoDB shell version: 2.4.9
connecting to: zxq
> db.zxq.insert({"zxq":"zxq"})
not authorized for insert on zxq.zxq
>

五、DB操作命令

db.addUser(userDocument)

//添加用户
> db.addUser("zxq","1234")
{
"user" : "zxq",
"readOnly" : false,
"pwd" : "3e7c9de5121b9c6b4c6c289b9c61c8f3",
"_id" : ObjectId("57a4f607da8f119aa039cf35")
}

db.adminCommand(nameOrDocument)

//切换到admin数据库并执行方法中的命令。
> db.adminCommand({shutdown : 1})
{ "ok" : 0, "errmsg" : "unauthorized" }
>

db.auth(username, password) //用户认证(用户连接)

> db.auth("zxq","1234")
1

db.cloneDatabase(fromhost) //从另一个服务器克隆当前选择的数据库

> db.cloneDatabase("localhost:27017")
{ "clonedColls" : [ "test.zxq", "test.zzz" ], "ok" : 1 }
> 
> db
test
> show collectionsshow collections
system.indexes
zxq
zzz
>

db.copyDatabase(fromdb, todb, fromhost)

db.copyDatabase('zxq','zxq1')  //本机zxq库copy至zxq1
> db.copyDatabase('zxq','zxq1','127.0.0.1:27017')  //其它主机zxq库copy至zxq1
{ "ok" : 1 }
> show dbsshow dbs
local   0.078125GB
test0.203125GB
zxq10.203125GB
> use zxq1use zxq1
switched to db zxq1
> show collectionsshow collections
aaa
ddd
system.indexes
system.users
t1
zxq
zxq123
>

db.createCollection(name, { size : …, capped : …, max : … } )

db.createCollection("log",{size:1024})
db.createCollection("zxq", {capped:true, size:100000, max:100})
//capped当于可以指定一个表可以占用空间的最大空间或指定一个表最大可容纳的记录数
//指定zxq这个表最大记录数为100,当第101条记录进来时,最早的记录会被自动删除
//限制它的空间大小为1M,如果超过1M的大小,则会删除最早的记录
> for(var i=1;i<=101;i++){db.zxq2.insert({name:"a"+i,age:1+i})}
> db.zxq2.find()
{ "_id" : ObjectId("57a599706c11d61f2a14e10a"), "name" : "a2", "age" : 3 } //age:2记录被自动删除
{ "_id" : ObjectId("57a599706c11d61f2a14e10b"), "name" : "a3", "age" : 4 }
{ "_id" : ObjectId("57a599706c11d61f2a14e10c"), "name" : "a4", "age" : 5 }
{ "_id" : ObjectId("57a599706c11d61f2a14e10d"), "name" : "a5", "age" : 6 }
{ "_id" : ObjectId("57a599706c11d61f2a14e10e"), "name" : "a6", "age" : 7 }
{ "_id" : ObjectId("57a599706c11d61f2a14e10f"), "name" : "a7", "age" : 8 }
{ "_id" : ObjectId("57a599706c11d61f2a14e110"), "name" : "a8", "age" : 9 }

db.currentOp()

[root@primary zxq]# ./mongo --port=27018
MongoDB shell version: 2.4.9
connecting to: 127.0.0.1:27018/test
> db.currentOp()  //显示当前的操作
{
        "inprog" : [
                {
                        "opid" : 887864,
                        "active" : true,
                        "secs_running" : 0,
                        "op" : "insert",
                        "ns" : "zxq1.zxq3",
                        "insert" : {

                        },
                        "client" : "127.0.0.1:24327",
                        "desc" : "conn2",
                        "threadId" : "0x7fec8fc71700",
                        "connectionId" : 2,
                        "locks" : {
                                "^" : "w",
                                "^zxq1" : "W"
                        },
                        "waitingForLock" : false,
                        "numYields" : 0,
                        "lockStats" : {
                                "timeLockedMicros" : {

                                },
                                "timeAcquiringMicros" : {
                                        "r" : NumberLong(0),
                                        "w" : NumberLong(1)
                                }
                        }
                }
        ]
}

db.dropDatabase()

//删除当前连接的数据库
> use zxq1use zxq1
switched to db zxq1
> db.dropDatabase()db.dropDatabase()
{ "dropped" : "zxq1", "ok" : 1 }
> show dbsshow dbs
local   0.078125GB
test    0.203125GB
>

db.eval(func, args)

利用db.eval函数可以在MongoDB服务器端执行javascript脚本,这个函数先将给定的
javascript字符串传递给MongoDB服务器,在服务器上执行,然后返回结果.
> db.eval("function(name){return 'hello,'+name;}",['refactor'])
hello,refactor

db.fsyncLock()

db.fsyncUnlock()

复制数据文件方式数据库:
直接拷贝数据目录下的一切文件。但是在拷贝过程中必须阻止数据文件发生更改。
因此需要对数据库加锁,以防止数据写入。
> db.fsyncLock()
{
"info" : "now locked against writes, use db.fsyncUnlock() to unlock",
"seeAlso" : "http://dochub.mongodb.org/core/fsynccommand",
"ok" : 1
}
> 
上面的命令将阻塞写入操作,并将脏数据刷新到磁盘上,确保数据一致。
然后,拷贝数据文件到备份目录下
然后,拷贝数据文件到备份目录下
cp -R /data/db/* /backup
文件复制完成后,对数据库进行解锁,允许写操作
> db.fsyncUnlock()
> 
注意: 在执行db.fsyncLock()和db.fsyncUnlock()时,
不能关闭当前的shell窗口,否则可能无法连接而需要重新启动mongod服务。
恢复时,确保mongod没有运行,清空数据目录,将备份的数据拷贝到数据目录下,
然后启动mongod
# cp -R /backup/* /data/db/
# mongod -f mongod.conf

db.getCollection(cname)

//获取文档名称
> db.getCollection("zxq")
zxq.zxq
//文档重命名
> db.getCollection('zxq').renameCollection('zxqzxq')
{ "ok" : 1 }
> show collectionsshow collections
aaa
ddd
system.indexes
system.users
t1
zxq123
zxqzxq

db.getCollectionNames()

> db.getCollectionNames()
[
        "aaa",
        "ddd",
        "system.indexes",
        "system.users",
        "t1",
        "zxq123",
        "zxqzxq"
]

//等同于show collections
> show collections
aaa
ddd
system.indexes
system.users
t1
zxq123
zxqzxq
>

db.getLastError()

db.getLastErrorObj()

//db.getLastError()返回上一次错误-如果没有错误则为空
//db.getLastErrorObj()查看完整的错误结果。
在没有错误的情况下,db.getLastErrorObj().err应该为空。
> db.getLastError()
null
> db.getLastErrorObj()
{ "n" : 0, "connectionId" : 3, "err" : null, "ok" : 1 }
> db.getLastErrorObj().err
null

db.getMongo()

> db.getMongo()db.getMongo()
connection to 127.0.0.1
>

db.getMongo().setSlaveOk()

对于replica set 中的secondary 节点默认是不可读的。在写多读少的应用中,
使用Replica Sets来实现读写分离。通过在连接时指定或者在主库指定slaveOk,
由Secondary来分担读的压力,Primary只承担写操作。
如果通过shell访问mongo,要在secondary进行查询。会出现如下错误:
imageSet:SECONDARY> db.fs.files.find()
error: { "$err" : "not master and slaveOk=false", "code" : 13435 }
有两种方法实现从机的查询:
第一种方法:db.getMongo().setSlaveOk();
第二种方法:rs.slaveOk();
但是这种方式有一个缺点就是,下次再通过mongo进入实例的时候,查询仍然会报错,为此可以通过下列方式
vi ~/.mongorc.js
增加一行rs.slaveOk();
这样的话以后每次通过mongo命令进入都可以查询了
//如果是通过java访问secondary的话则会报下面的异常
com.mongodb.MongoException: not talking to master and retries used up
解决的办法很多:
第一种方法:在java代码中调用dbFactory.getDb().slaveOk();
第二种方法:在java代码中调用
dbFactory.getDb().setReadPreference(ReadPreference.secondaryPreferred());
//在复制集中优先读secondary,如果secondary访问不了的时候就从master中读
或
dbFactory.getDb().setReadPreference(ReadPreference.secondary());
//只从secondary中读,如果secondary访问不了的时候就不能进行查询
第三种方法:在配置mongo的时候增加slave-ok="true"也支持直接从secondary中读
<mongo:mongo id="mongo" host="${mongodb.host}" port="${mongodb.port}">
<mongo:options slave-ok="true"/> 
</mongo:mongo>

db.getName()

> db.getName()
zxq
//等同db
> db
zxq

db.getPrevError()

查询之前的错误信息
> db.getPrevError();
{ "err" : null, "n" : 0, "nPrev" : -1, "ok" : 1 }
> 
清除错误记录
> db.resetError();
{ "ok" : 1 }

db.getProfilingLevel()

mongodb可以通过profile来监控数据,进行优化
查看当前是否开启profile功能用命令
返回level等级,值为0|1|2,分别代表意思:
0代表关闭,1代表记录慢命令,2代表全部
开始profile功能:
db.setProfilingLevel(level);  
#level等级,值同上
level为1的时候,执行较慢命令默认值为100ms,更改为
db.setProfilingLevel(level,slowms)
如db.setProfilingLevel(1,50)这样就更改为50毫秒
> db.system.profile.find({millis:{$gt:500}}) //所花时间大于500毫秒
>  
{ "ts" : ISODate("2011-07-23T02:50:13.941Z"), 
"info" : "query order.order reslen:11022 nscanned:672230  \nquery: { status: 1.0 } nreturned:101
bytes:11006 640ms", "millis" : 640 }  
{ "ts" : ISODate("2011-07-23T02:51:00.096Z"), 
"info" : "query order.order reslen:11146 nscanned:672302  \nquery: { status: 1.0, user.uid: 
{ $gt: 1663199.0 } }  nreturned:101 bytes:11130 647ms", "millis" : 647 }  
注释:
ts:命令执行时间
info:命令的内容
query:代表查询
order.order: 代表查询的库与集合
reslen:返回的结果集大小,byte数
nscanned:扫描记录数量
nquery:后面是查询条件
nreturned:返回记录数及用时
millis:所花时间

db.setProfilingLevel(level,) 0=off 1=slow 2=all

db.getProfilingStatus()

> db.getProfilingStatus()db.getProfilingStatus()
{ "was" : 0, "slowms" : 100 }
> db.setProfilingLevel(1,50)
{ "was" : 0, "slowms" : 100, "ok" : 1 }
> db.getProfilingStatus()
{ "was" : 1, "slowms" : 50 }

db.getReplicationInfo()

获取当前数据库集群的复制集信息。

db.getSiblingDB(name)

> db.getSiblingDB("zxq")
zxq

db.hostInfo()

> db.hostInfo()
{
        "system" : {
                "currentTime" : ISODate("2016-08-06T09:42:13.512Z"),
                "hostname" : "primary",
                "cpuAddrSize" : 64,
                "memSizeMB" : 2910,
                "numCores" : 1,
                "cpuArch" : "x86_64",
                "numaEnabled" : false
        },
        "os" : {
                "type" : "Linux",
                "name" : "",
                "version" : ""
        },
        "extra" : {
                "versionString" : "Linux version 2.6.32-358.el6.x86_64 
                (mockbuild@x86-022.build.eng.bos.redhat.com) 
                (gcc version 4.4.7 20120313 
                (Red Hat 4.4.7-3) (GCC) ) #1 SMP Tue Jan 29 11:47:41 EST 2013",
                "libcVersion" : "2.12",
                "kernelVersion" : "2.6.32-358.el6.x86_64",
                "cpuFrequencyMHz" : "2497.522",
                "cpuFeatures" : "fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca 
                cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx rdtscp lm constant_tsc up 
                rep_good xtopology nonstop_tsc unfair_spinlock pni pclmulqdq monitor ssse3 cx16 
                sse4_1 sse4_2 popcnt aes xsave avx rdrand hypervisor lahf_lm",
                "pageSize" : NumberLong(4096),
                "numPages" : 745116,
                "maxOpenFiles" : 1024
        },
        "ok" : 1
}
>

db.isMaster()

//主库状态
> db.isMaster()
{
        "ismaster" : true,
        "maxBsonObjectSize" : 16777216,
        "maxMessageSizeBytes" : 48000000,
        "localTime" : ISODate("2016-08-06T09:45:54.651Z"),
        "ok" : 1
}

db.killOp(opid)

停止(杀死)在当前库的当前操作,可以用来杀掉长查询

//诊断1(返回所有与写有关的操作)
db.currentOp(
   {
     "waitingForLock" : true,
     $or: [
        { "op" : { "$in" : [ "insert", "update", "remove" ] } },
        { "query.findandmodify": { $exists: true } }
    ]
   }
)

//诊断2(返回正在运行的操作)
db.currentOp(
   {
     "active" : true,
     "numYields" : 0,
     "waitingForLock" : false
   }
)

//诊断3(在zxq数据库上运行时长超过3S的操作)
db.currentOp(
   {
     "active" : true,
     "secs_running" : { "$gt" : 3 },
     "ns" : /^zxq\./
   }
)

//诊断4(返回创建索引的操作)        
db.currentOp(
    {
      $or: [
        { op: "query", "query.createIndexes": { $exists: true } },
        { op: "insert", ns: /\.system\.indexes\b/ }
      ]
}
)


//db.currentOp(true) //显示所有会话操作,包括空闲
> db.currentOp(true)
{
        "inprog" : [
                {
                        "opid" : 1526256,
                        "active" : true,
                        "secs_running" : 0,
                        "op" : "insert",
                        "ns" : "zxq.zzzz",
                        "insert" : {
                          },
                        "client" : "127.0.0.1:12599",
                        "desc" : "conn4",
                        "threadId" : "0x7ff3135bd700",
                        "connectionId" : 4,
                        "locks" : {
                                "^" : "w"
                        },
                        "waitingForLock" : false,
                        "numYields" : 0,
                        "lockStats" : {
                                "timeLockedMicros" : {
                                        "r" : NumberLong(0),
                                        "w" : NumberLong(57)
                                },
                            "timeAcquiringMicros" : {
                                        "r" : NumberLong(0),
                                        "w" : NumberLong(7)
                                }
                        }
                }
        ]
}

//杀掉操作
> db.killOp(1526256)
{ "info" : "attempting to kill op" }
>

未完待续......

  • 发表评论
  • 查看评论
【暂无评论!】

发表评论:

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。