nosql 泛指非关系数据库 存储格式key=>value
memcached redis 内存缓存数据库
MongoDB是由C++语言编写的一个基于分布式文件存储的开源数据库系统，它的目的在于为WEB应用提供可扩展的高性能数据存储解决方案。
MongoDB是一个介于关系型数据库和非关系型数据库之间的产品，是非关系型数据库当中功能最丰富，最像关系型数据库的。它支持的数据结构非常松散，会将数据存储为一个文档，数据结构由键值对(key=>value)组成，是类似于json的bson格式，字段值可以包含其它文档、数组和文档数组，因此可以存储比较复杂的数据类型。
MongoDB最大的特点就是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系型数据库单表查询的绝大部分功能，而且还支持对数据建立索引。
MongoDB官网：http://www.mongodb.org/
MongoDB学习网站：http://www.runoob.com/mongodb
比较适合存储大量的没有规则、无序的数据。
存储量大：单表实现存储PB级别的数据
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1EB （Exabyte 百亿亿字节 艾字节）=1024PB，
1ZB （Zettabyte 十万亿亿字节 泽字节）= 1024EB，
1YB （Yottabyte 一亿亿亿字节 尧字节）= 1024ZB，
数据的效率，就是指存储和读写速度。
mongodb在有索引的情况下查询方面的速率是myisam和innodb的几倍,没有索引就比较慢，插入的速率很快，不管是不是有索引
2.3、结构
database database 数据库
table collection 数据库表/集合
row document 数据记录行/文档
column field 数据字段
index index 索引
yum方式安装：https://docs.mongodb.com/manual/tutorial/install-mongodb-on-red-hat/
手动通用安装：https://docs.mongodb.com/manual/tutorial/install-mongodb-on-linux/
①上传安装包到服务器目录
②解压到安装目录 并移动
shell > tar xvf mongodb-linux-x86_64-rhel62-3.6.5.tgz
shell > mv mongodb-linux-x86_64-rhel62-3.6.5 /usr/local/mongodb
③创建数据存储目录和日志目录
shell > cd /usr/local/mongodb
shell > mkdir data
shell > mkdir logs
④启动mongod服务
shell > cd /usr/local/mongodb/bin
shell > ./mongod --dbpath=/usr/local/mongodb/data --logpath=/usr/local/mongodb/logs/log.txt --fork
指定数据目录和日志目录，如果想要指定远程链接的话 添加 --bind_ip=0.0.0.0
shell > ./mongod --dbpath=/usr/local/mongodb/data --logpath=/usr/local/mongodb/logs/log.txt --bind_ip=0.0.0.0 --fork
(
远程链接
1.远程服务器需要有mongo客户端工具，这里可以将/usr/local/mongodb/bin/mongo传到另一台服务器
2.# scp /usr/local/mongodb/bin/mongo root@192.168.1.12:/usr/local/mongodb/bin/ (rsync -av 也可以)
3.另一台服务器# ./mongo 192.168.1.11 就可以链接到
)
参数介绍：
dbpath 数据存储路径
logpath 日志存储路径
fork 后台启动
auth 权限开启
bind_ip 指定绑定网卡ip
3、命令行客户端操作
# /usr/local/mongodb/bin.mongo
配置官方yum源
[root@hd1 yum.repos.d]# cat mongodb-org-6.0.repo
[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
如果有二进制安装的，先关闭
1.kill杀死，但是可能会造成一定的报错
ps -ef | grep mongo
kill掉server
2.使用 shutdownServer
# cd /use/local/mongodb/bin
# ./mongo
> use admin
> db.shutdownServer()
3.到mongodb目录的bin目录下
# ./mongod --shutdown
安装
[root@hd1 yum.repos.d]# yum install -y mongodb-org
启动
[root@hd1 ~]# systemctl start mongod
查看是否监听端口
[root@hd1 ~]# netstat -naput |grep mongod
mongodb里存储数据的格式文档形式，以bson格式的文档形式。
BSON （）是一种类json的一种二进制形式的存储格式，简称Binary JSON，它和JSON一样，支持内嵌的文裆对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和BinData类型。
在mongodb中，可以无需创建数据库和集合，使用的时候会自动创建
创建一个库devops
语法：
db.集合名称.insert（bson格式数据）
db.goods.insert({name:‘huawei01’,price:1000,weight:135,number:35})
db.goods.insert({name:‘xiaomi5’,price:1999,weight:156,number:45,area:{province:‘beijing’,city:‘beijing’}})
db.goods.insert({name:‘xiaomimax’,price:2000,weight:180,number:100,area:{province:‘henan’,city:‘zhengzhou’},color:[‘black’,‘white’,‘red’]})
语法：db.集合名称.find(查询条件)
findOne(查询条件)
不进行条件限制，全部取出来。
findOne会取出符合结果的第一条信息，并且以格式化形式返回
条件格式，所见及所得
db.goods.find({name:‘xiaomimax’})
db.goods.findOne({name:‘xiaomimax’})
mysql < <= > >= !=
mongo $lt $lte $gt $gte KaTeX parse error: Expected '}', got 'EOF' at end of input: ….find({price:{'lte’:1999}})
db.goods.find({price:{‘$lt’:1999}})
类似mysql中的AND语法
db.goods.find({price:{‘KaTeX parse error: Expected 'EOF', got '}' at position 10: lte':1999}̲,number:{'gte’:40}})
通过多维字段的值进行查询
db.goods.find({‘area.city’:‘zhengzhou’});
注意：多维字段需要用引号包含起来
①查询满足其中之一即可显示
db.goods.find({color:‘black’})
②满足查询条件所有的才可显示
db.集合名称.find({字段(数组):{‘KaTeX parse error: Expected 'EOF', got '}' at position 13: all’:[v1,v2]}̲}) db.goods.ins…all’:[‘black’,‘gold’]}})
在实际使用环境，不需要查询并显示太多的字段。可以选择设定显示。
语法：db.集合名称.find({查询条件},{筛选条件})
显示为1,不显示为0 要是1都是1，要是0都是0 _id除外
db.goods.find({color:{‘$all’:[‘black’,‘gold’]}},{name:1,_id:0})
注意采用合适的方式，显示出查询字段值内容
_id是mongodb数据库里的集合中，默认的主键id，具有索引内容，通过主键查询，会很快的查询速度。不要随意修改此值，使用默认即可。
满足其中之一的条件就可以显示，类似mysql的中的or条件语法
select * from goods where price > 5000 or number >= 100
db.goods.find({‘KaTeX parse error: Expected '}', got 'EOF' at end of input: or':[{price:{'gt’:5000}},{number:{‘$gte’:100}}]})
返回结果的数量统计
链式操作
db.goods.count()
db.goods.find({price:{‘KaTeX parse error: Expected 'EOF', got '}' at position 9: gt':5000}̲}).count() db.g…gt’:5000}})
类似于mysql中的limit（skip,length）语法
limit() 取几个
skip() 跳过几个
db.goods.find().limit(1);
db.goods.find().skip(1).limit(1);
mongodb语法和SQL语句的对比
语法：db.集合名称.update({查询条件},{修改条件})
updateOne() 修改匹配的第一条
updateMany() 修改匹配所有条
db.goods.update({name:‘iphonex’},{‘$set’:{price:8500}})
db.goods.updateOne({name:‘xiaomi5’},{‘$set’:{price:1500}})
没有$set关键字语法，把设置的字段进行修改,没有设置的就会被删除掉
db.goods.update({name:‘iphonex’},{price:8550})
语法： db.集合名称.remove({查询条件})
deleteOne() 删除匹配的第一条
deleteMany() 删除匹配的多条
db.goods.remove({price:8550})
db.goods.deleteMany({price:{‘$lte’:2000}})
可以删除某个字段的操作，使用的是update语法的KaTeX parse error: Expected '}', got 'EOF' at end of input: …:'huawei01'},{'unset’:{weight:0}})
值给一个就可以删除了
真实业务当中，一般不做物理删除，会使用一个标识，来确认是否已经被删除的数据
https://docs.mongodb.com/manual/tutorial/create-users/
mongodb安全事件：https://www.jianshu.com/p/48d17a69e190
①使用另外一台虚拟机，使用mongo命令行端进行测试
远程登录方法
②关闭mongodb
正常情况下不要kill -9 mongod，使用mongo命令客户端里的关机命令
# ./mongod --shutdown
③添加启动的脚本，启动mongod,或者指定启动
shell > vim /etc/init.d/mongodb 脚本懒得写
指定启动
# ./mongod --dbpath=/usr/local/mongodb/data --logpath=/usr/local/mongodb/logs/log.txt --bind_ip=0.0.0.0 --fork
bind绑定是外网通讯的网卡 --bind_ip_all表示绑定0.0.0.0这个任意地址
④使用远程登录mongod服务
# ./mongo 192.168.1.11
2、用户权限管理
需求：设置一个超级管理员账户，对于所有库具有读写权限
语法：
db.createUser({user:“root”,pwd:“root”,roles:[“root”]})
实现步骤：
①切换admin库，进行用户创建
> use admin
②关闭mongod服务，重启添加权限参数并启动
> db.shutdownServer()
在启动脚本中加入–auth参数
# ./mongod --dbpath=/usr/local/mongodb/data --logpath=/usr/local/mongodb/logs/log.txt --bind_ip=0.0.0.0 --auth --fork
③测试使用
# ./mongo
> use ope 创建并进入ope
显示没有权限，这里需要登录
>use admin 登录用户需要切换到admin下，因为用户就是在admin下创建的
>db.auth('root','root')
添加用户，限制用户的库的权限，只读
> db.createUser({user:'ope',pwd:'ope123',roles:[{role:"read",db:"ope"}]})
ope用户对于ope库只有只读权限
> db.auth('ope','ope123') 登录
> db.集合（表）.find()
>
//导出 一张表（集合）
./mongoexport -uroot -proot --authenticationDatabase=admin -d devops -c goods --out /usr/local/mongodb/goods.json
//导入 集合
./mongoimport -uroot -proot --authenticationDatabase=admin -d haha -c hehe --file=/usr/local/mongodb/goods.json
//全库备份
./mongodump -uroot -proot --authenticationDatabase=admin -d devops --out /usr/local/mongodb/goods.json
这里恢复是需要到文件中一个一个恢复
①上传php扩展包
如果没有phpize这个命令，需要yum安装php-devel
②解压编译安装需要php的5.5版本，但是yum安装的php是5.4，不符合要求
#1. 卸载老版本php5.4
shell > yum remove php*
#2. 检查还有没有php
shell > yum list installed|grep php
#2.查看是否有5.6的软件包（默认没有）
shell > yum list php56w
#3.安装扩展源
shell > yum -y install epel-release
#4. 安装remi源
shell > rpm -Uvh http://rpms.remirepo.net/enterprise/remi-release-7.rpm
#5. 安装yum-config-manager管理工具
shell > yum -y install yum-utils
#6. 安装php
shell > yum-config-manager --enable remi-php56
shell > yum -y install php php-opcache
shell > yum -y install php-mysql php-gd php-ldap php-odbc php-pear php-xml php-xmlrpc php-mbstring php-soap curl curl-devel
#7. 安装php进程管理器
shell > yum -y install php-fpm (端口9000)
#7.安装php-devel
shell > yum -y install php-devel
#8. 开启php-fpm
shell > systemctl start php-fpm.service
#9.查看安装的包，查看版本
shell > rpm -qa|grep php
shell > php -v
shell > yum -y install php-devel #安装phpize
shell > tar xvf mongodb-1.5.3.tgz
shell > cd mongodb-1.5.3
shell > phpize
shell > ./configure && make && make install
③添加php.ini匹配
shell > vim /etc/php.ini
④重启php-fpm查看phpinfo
shell > service php-fpm restart
⑤部署lnmp环境
# yum -y install nginx
# cd /usr/share/nginx/html/
# cat index.php
();
?>
修改主配置文件，添加index.php 几行内容
# vi /etc/nginx/nginx.conf
server_name _;
root /usr/share/nginx/html;
index index.php index.html; 添加这行
location ~ \.php$ { 添加location
root /usr/share/nginx/html;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
[root@node3 ~]# systemctl restart nginx
测试 浏览器
192.168.8.139/index.php
这是一个windows端远程链接软件，类似navicat可以链接mysql
具体就不展示了，直接搜robo3t就有教程
很多网站需要统计某个页面或者某个功能访问量，如果访问量比较大，需要记录的组件具有很快的读写效率。
可以使用功能性更多的mongodb来完成此业务。mongodb具有更多的数据灵活性。
网站访问日志记录的信息：
ip 用户访问的来源ip
url 用户访问的地址 功能模块页面地址
time 访问时间 记录用户访问的时间值
user_agent 用户访问的客户端信息
这里使用的是php脚本文件
# cd /usr/share/nginx/html/
# vim index.php
// +----------------------------------------------------------------------
// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006-2016 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: liu21st 注意用户名，密码，ip地址，数据库
访问页面之后，可以查看到访问已经被记录
1.浏览器输入ip地址/index.php
2.查看mongodb中的jilu下的logs 这里使用链接器更好观察
master-slave架构中master节点负责数据的读写，slave没有写入权限只负责读取数据。
在主从结构中，主节点的操作记录成为oplog（operation log）。oplog存储在系统数据库local的oplog.$main集合中，这个集合的每个文档都代表主节点上执行的一个操作。从服务器会定期从主服务器中获取oplog记录，然后在本机上执行！对于存储oplog的集合，MongoDB采用的是固定集合，也就是说随着操作过多，新的操作会覆盖旧的操作！
主从结构没有自动故障转移功能，需要指定master和slave端，不推荐在生产中使用。
MongoDB 高可用的基础是副本集，副本集本质来说就是一份数据存多份，保证数据在生产部署时的冗余和可靠性。
利用副本集可以实现：
高可用：通过在不同的机器上保存副本来保证数据的不会因为单点损坏而丢失，主节点宕机后，由备节点自动选举成为新的主节点
读写分离：读请求可以分流到备节点，减轻主节点的单点压力。而且，由不同的服务器为不同的用户提供服务，提高整个系统的负载。
副本集的典型架构有以下三种角色：
至少一个主节点（Primary）：负责整个集群的写操作入口，主节点挂掉之后会自动选出新的主节点。
一个或多个从节点（Secondary）：一般是 2 个或以上，从主节点同步数据，在主节点挂掉之后选举新节点。
零个或 1 个仲裁节点（Arbiter）：这个是为了节约资源或者多机房容灾用，只负责主节点选举时投票不存数据，保证能有节点获得多数赞成票。
一个三节点的复制集群可能是 PSS 或者 PSA 结构
在PSS架构中，当主库宕机后，两个从库都会进行竞选，其中一个变为主库，当原主库恢复后，作为从库加入当前的复制集群即可。
副本集中的每个节点上都会定时向其他节点发送心跳(heartbeat)，以此来感知其他节点的变化，比如是否失效、或者角色发生了变化。
默认情况下，节点会每2秒向其他节点发出心跳，这其中包括了主节点。 如果备节点在10秒内没有收到主节点的响应就会主动发起选举。
MongoDB 副本集通过 Raft 算法来完成主节点的选举。 整个过程对于上层是透明的，应用并不需要感知，因为 Mongos 会自动发现这些变化。
MongoDB 的主从同步机制是确保数据一致性和可靠性的重要机制。其同步的基础是 Oplog，类似 MySQL 的 Binlog。
在每一个副本集的节点中，都会存在一个名为local.oplog.rs的特殊集合。 当 Primary 上的写操作完成后，会向该集合中写入一条Oplog，而 Secondary 则持续从 Primary 拉取新的 Oplog 并在本地进行回放以达到同步的目的。
MongoDB 对于 Oplog 的设计是比较仔细的，比如：
Oplog 必须保证有序，通过 optime 来保证。
Oplog 必须包含能够进行数据回放的完整信息。
Oplog 必须是幂等的，即多次回放同一条日志产生的结果相同。
Oplog 集合是固定大小的，为了避免对空间占用太大，旧的 oplog 记录会被滚动式的清理。
主从同步的本质实际上就是，Primary 节点接收客户端请求，将更新操作写到 Oplog，然后 Secondary 从同步源拉取 Oplog 并本地回放，实现数据的同步
上面提到了 MongoDB 的写只写了内存和 Oplog ，并没有做数据持久化，Checkpoint 就是将内存变更刷新到磁盘持久化的过程。MongoDB 会每 60s 一次将内存中的变更刷盘，并记录当前持久化点（checkpoint），以便数据库在重启后能快速恢复数据。
MongoDB宕机重启之后可以通过 checkpoint 快速恢复上一个 60s 之前的数据。
MongoDB最后一个 checkpoint 到宕机期间的数据可以通过 Oplog 回放恢复。
Oplog因为是 100ms 刷盘一次，因此至多会丢失 100ms 的数据（这个可以通过 WriteConcern 的参数控制不丢失，只是性能会受影响，适合可靠性要求非常严格的场景）
如果在写数据开启了多数写，那么就算 Primary 宕机了也是至多丢失 100ms 数据
mongodb操作日志 oplog
reis没有日志，依靠快照进行传送，使用命令实现主从
yum方式安装：https://docs.mongodb.com/manual/tutorial/install-mongodb-on-red-hat/
配置官方yum源
[root@hd1 yum.repos.d]# cat mongodb-org-6.0.repo
[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
如果有二进制安装的，先关闭
# cd /use/local/mongodb/bin
# ./mongo
> use admin
> db.shutdownServer()
或者 直接ps -ef | grep mongo
kill掉server
安装
[root@hd1 yum.repos.d]# yum install -y mongodb-org
启动
[root@hd1 ~]# systemctl start mongod
查看是否监听端口
[root@hd1 ~]# netstat -naput |grep mongod
同理hd2 hd3 安装mongodb-org
实验拓扑结构如下：
192.168.8.138为主，192.168.8.139、192.168.8.137为从
1.设置主库192.168.8.138的主配置文件/etc/mongod.conf内容如下
[root@hd1 ~]# vi /etc/mongod.conf #部分配置
# network interfaces
net:
port: 27017
bindIp: 192.168.8.139,127.0.0.1
replication:
replSetName: "rs0"
[root@hd1 ~]# systemctl restart mongod
查看端口
[root@hd1 ~]# netstat -naput |grep 27017
tcp 0 192.168.8.139:27017
同理hd2和hd3的配置如下：
[root@hd2 ~]# vi /etc/mongod.conf #部分配置
# network interfaces
net:
port: 27017
bindIp: 192.168.8.139,127.0.0.1
replication:
replSetName: "rs0"
[root@hd3 ~]# vi /etc/mongod.conf #部分配置
# network interfaces
net:
port: 27017
bindIp: 192.168.8.139,127.0.0.1 (这里如果一直报错就设置0.0.0.0)
replication:
replSetName: "rs0"
#重启服务，并查看端口是否正确监听
初始化副本集，用mongosh登陆
[root@hd1 ~]# mongosh
初始化
rs.initiate( {
_id : "rs0",
members: [
{ _id: 0, host: "192.168.8.139:27017" },
{ _id: 1, host: "192.168.8.138:27017" },
{ _id: 2, host: "192.168.8.137:27017" }
]
})
查看主从复制
rs0 [direct: other] test> rs.conf()
确保副本集有一个主库
rs0 [direct: primary] test> rs.status()
验证副本集主库可写，从库可读 (注意:默认节点下从节点不能读取数据)
验证主节点的写入
rs0 [direct: primary] test> use devops
db.goods.insert({name:'huawei01',price:1000,weight:135,number:35})
验证从节点读取
登陆到192.168.1.12的mongosh
设置将读首选项更改为 "secondaryPreferred" 可以在 primary 不可用时从 secondary 节点读取数据，并避免出现错误。可以在连接字符串中设置 readPreference 或使用 db.getMongo().setReadPref() 方法设置读优先级别
rs0 [direct: secondary] devops> db.getMongo().setReadPref('secondaryPreferred');
分片技术一般是指水平扩展，它是omngodb的另一个核心特性，支持海量数据存储
就是水平扩展，是MongoDB的另一个核心特性，它是 MongoDB 支持海量数据存储的基础。MongoDB 天然的分布式特性使得它几乎可无限的横向扩展。
尽管分片起源于关系型数据库分区，但MongoDB分片完全又是另一回事。和MySQL分区方案相比，MongoDB的最大区别在于它几乎能自动完成所有事情，只要告诉MongoDB要分配数据，它就能自动维护数据在不同服务器之间的均衡。
1.存储容量需求超出单机磁盘容量。
2.活跃的数据集超出单机内存容量，导致很多请求都要从磁盘读取数据，影响性能。
3.IOPS超出单个MongoDB节点的服务能力，随着数据的增长，单机实例的瓶颈会越来越明显。
4.副本集具有节点数量限制。
分片集群由以下3个服务组成：
Mongos ：路由服务，不存具体数据，从 Config 获取集群配置讲请求转发到特定的分片，并且整合分片结果返回给客户端。
Config Server：保存集群的元数据（metadata），包含各个Shard的路由规则，配置服务器由一个副本集(ReplicaSet)组成。
Shard：用于存储真正的集群数据，可以是一个单独的 Mongod实例，也可以是一个副本集。 生产环境下Shard一般是一个 Replica Set，以防止该数据片的单点故障。
为了在数据集合中分配文档，MongoDB使用分片主键分割集合。
分片集群上数据管理单元叫chunk，一个 chunk 默认 64M。
Mongos 在操作分片集合时，会自动根据分片键找到对应的 chunk，并向该 chunk 所在的分片发起操作请求。
1范围分片（Range based sharding）
范围分片是基于分片主键的值切分数据，每一个区块将会分配到一个范围。
范围分片适合满足在一定范围内的查找，例如查找X的值在[20,30)之间的数据，mongo 路由根据Config server中存储的元数据，可以直接定位到指定的shard的Chunk中。
缺点: 如果shard key有明显递增（或者递减）趋势，则新插入的文档多会分布到同一个chunk，无法扩展写的能力。
2 hash分片（Hash based sharding）
Hash分片是计算一个分片主键的hash值，每一个区块将分配一个范围的hash值。
由于 hash值的计算是随机的，因此 Hash 分片具有很好的离散性，可以将数据随机分发到不同的 chunk 上。Hash 分片可以充分的扩展写能力，弥补了范围分片的不足，但不能高效的服务范围查询，所有的范围查询要查询多个 chunk 才能找出满足条件的文档
MongoDB 的分片集群有个非常重要的特性是其它数据库没有的，这个特性就是数据的自动均衡。
当一个chunk的大小超过配置中的chunk size时，MongoDB的后台进程会把这个chunk切分成更小的chunk。
MongoDB 在运行时会自定检测不同分片上的 chunk 数，当发现最多和最少的差异超过阈值就会启动 rebalance，使得每个分片上的 chunk 数差不多
最佳实践，配置复制集成员推荐使用dns主机名而不是ip地址
mongodb5.0开始，只用ip地址配置的节点将无法启动验证，也不会启动
注意：config server副本集不能与任何分片副本集使用相同的名称
一台服务器上进行部署
两个分片集群
名词解释
垂直扩展：增加更多的CPU和存储资源来扩展容量。
水平扩展：将数据集分布在多个服务器上。水平扩展即分片。
#创建数据目录 ： 准备给两个复制集使用，每个复制集有三个实例 ,共 6 个数据节点
[root@hd3 ~]# mkdir /data
[root@hd3 ~]# cd /data
[root@hd3 data]# mkdir -p shard1 second1 second2
[root@hd3 data]# mkdir -p shard2 second21 second22
[root@hd3 data]# mv second1 second11
[root@hd3 data]# mv second2 second12
[root@hd3 data]# touch shard1/mongod.log
[root@hd3 data]# touch second11/mongod.log
[root@hd3 data]# touch second12/mongod.log
[root@hd3 data]# touch shard2/mongod.log
[root@hd3 data]# touch second21/mongod.log
[root@hd3 data]# touch second22/mongod.log
[root@hd3 data]# cat /etc/passwd|grep mong
mongod:x:986:980:mongod:/var/lib/mongo:/bin/false
#授权
[root@hd3 data]# chown -R mongod.mongod /data
#启动第一个 mongod 分片实例( 一共三个实例)
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet shard1 --dbpath /data/shard1 --logpath /data/shard1/mongod.log --port 27010 --fork --shardsvr
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet shard1 --dbpath /data/second11 --logpath /data/second11/mongod.log --port 27011 --fork --shardsvr
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet shard1 --dbpath /data/second12 --logpath /data/second12/mongod.log --port 27012 --fork --shardsvr
#对第一个分片集群进行初始化实例都启动好了后，将其加入到复制集中
[root@hd3 data]# mongosh --port 27010
test> rs.initiate(
{_id:"shard1",
"members":[
{"_id":0,"host":"h1:27010"},
{"_id":1,"host":"h1:27011"},
{"_id":2,"host":"h1:27012"}
]
});
（注意：1.主机名和ip是否一致 /etc/hosts 2.端口问题 3.文件）
#搭建第二个分片 ，和上面一样只需要修改下路径和端口
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet shard2 --dbpath /data/shard2 --logpath /data/shard2/mongod.log --port 28010 --fork --shardsvr
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet shard2 --dbpath /data/second21 --logpath /data/second21/mongod.log --port 28011 --fork --shardsvr
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet shard2 --dbpath /data/second22 --logpath /data/second22/mongod.log --port 28012 --fork --shardsvr
#登陆第二分片集群并初始化，等待集群选举
[root@hd3 data]# mongosh --port 28010
test> rs.initiate(
{_id:"shard2",
"members":[
{"_id":0,"host":"h1:28010"},
{"_id":1,"host":"h1:28011"},
{"_id":2,"host":"h1:28012"}
]
});
#查看状态
shard2 [direct: other] test> rs.status()
#配置Config 复制集：一共三个实例
[root@hd3 data]# mkdir -p config config1 config2
[root@hd3 data]# touch config/mongod.log config1/mongod.log config2/mongod.log
#启动复制集群
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet config --dbpath /data/config/ --logpath /data/config/mongod.log --port 37010 --fork --configsvr
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet config --dbpath /data/config1/ --logpath /data/config1/mongod.log --port 37011 --fork --configsvr
[root@hd3 data]# mongod --bind_ip 0.0.0.0 --replSet config --dbpath /data/config2/ --logpath /data/config2/mongod.log --port 37012 --fork --configsvr
#配置复制集进行初始化
[root@hd3 data]# mongosh --port 37010
test> rs.initiate(
{_id:"config",
"members":[
{"_id":0,"host":"h1:37010"},
{"_id":1,"host":"h1:37011"},
{"_id":2,"host":"h1:37012"}
]
});
#查看状态
config [direct: primary] test> rs.status()
#配置mongs 路由节点
[root@hd3 data]# mkdir mongos
[root@hd3 data]# touch mongos/mongos.log
[root@hd3 data]# mongos --bind_ip 0.0.0.0 --logpath /data/mongos/mongos.log --port 4000 --fork --configdb config/h1:37010,h1:37011,h1:37012
#登陆路由节点
[root@hd3 data]# mongosh --port 4000
#添加分片集群
[direct: mongos] test> sh.addShard("shard1/h1:27010,h1:27011,h1:27012");
[direct: mongos] test> sh.addShard("shard2/h1:28010,h1:28011,h1:28012");
#查看分片状态
[direct: mongos] test> sh.status();
#首先需要 启用数据库分片（order为数据库）
[direct: mongos] test> sh.enableSharding("order");
{
ok: 1,
#对collection进行分片sh.shardCollection("库名.集合名",{_id: "hashed"});
[direct: mongos] test> sh.shardCollection("order.orders",{_id:"hashed"});
[direct: mongos] test> use order
switched to db order
#插入四条数据
[direct: mongos] order> db.orders.insert({name:'huawei01',price:1000,weight:135,number:35})
[direct: mongos] order> db.orders.insert({name:'huawei02',price:2000,weight:235,number:45})
[direct: mongos] order> db.orders.insert({name:'xiaomi',price:2000,weight:235,number:45})
[direct: mongos] order> db.orders.insert({name:'maxxiaomi',price:2000,weight:235,number:45})
#登陆第一个分片集群
[root@hd3 ~]# mongosh --port 27010
shard1 [direct: primary] test> use order
switched to db order
shard1 [direct: primary] order> db.orders.find()
[
{
_id: ObjectId("648daa57a52e58a4a63e79fa"),
name: 'huawei02',
price: 2000,
weight: 235,
number: 45
},
{
_id: ObjectId("648daa63a52e58a4a63e79fb"),
name: 'xiaomi',
price: 2000,
weight: 235,
number: 45
}
]
#登陆第二个分片集群主服务器
[root@hd3 ~]# mongosh --port 28010
shard2 [direct: primary] test> use order
switched to db order
shard2 [direct: primary] order> db.orders.find()
[
{
_id: ObjectId("648daa46a52e58a4a63e79f9"),
name: 'huawei01',
price: 1000,
weight: 135,
number: 35
},
{
_id: ObjectId("648daa6fa52e58a4a63e79fc"),
name: 'maxxiaomi',
price: 2000,
weight: 235,
number: 45
}
]
#登陆第二分片集群，从库
[root@hd3 ~]# mongosh --port 28011
#设置从库可以读数据
shard2 [direct: secondary] order> db.getMongo().setReadPref('secondaryPreferred');
shard2 [direct: secondary] order> db.orders.find() #use order
[
{
_id: ObjectId("648daa46a52e58a4a63e79f9"),
name: 'huawei01',
price: 1000,
weight: 135,
number: 35
},
{
_id: ObjectId("648daa6fa52e58a4a63e79fc"),
name: 'maxxiaomi',
price: 2000,
weight: 235,
number: 45
}
]