数据库(Mysql、Hive、Hbase、MongoDB)环境搭建

MYSQL(单机安装)

1. 上传mysql安装包
2. 解压：
[root@mylove ~]# tar -xvf MySQL-5.6.26-1.linux_glibc2.5.x86_64.rpm-bundle.tar
3. 安装mysql的server包
[root@mylove ~]# rpm -ivh MySQL-server-5.6.26-1.linux_glibc2.5.x86_64.rpm
依赖报错：缺少perl 和 libaio

error: Failed dependencies:
perl is needed by MySQL-server-5.6.26-1.linux_glibc2.5.x86_64
libaio.so.1()(64bit) is needed by MySQL-server-5.6.26-1.linux_glibc2.5.x86_64
libaio.so.1(LIBAIO_0.1)(64bit) is needed by MySQL-server-5.6.26-1.linux_glibc2.5.x86_64
libaio.so.1(LIBAIO_0.4)(64bit) is needed by MySQL-server-5.6.26-1.linux_glibc2.5.x86_64

(1) 查找相关安装包:yum list | grep perl
安装perl.x86_64 : yum install perl.x86_64

(2) 查找相关安装包:yum list | grep libaio
安装perl.x86_64 : yum install libaio.x86_64

[root@mylove ~]# rpm -ivh MySQL-server-5.6.26-1.linux_glibc2.5.x86_64.rpm
又出错：包冲突conflict with
(3) 移除老版本的冲突包：mysql-libs-5.1.73-3.el6_5.x86_64
[root@mylove ~]# rpm -e mysql-libs-5.1.73-5.el6_6.x86_64 --nodeps

(4) 继续重新安装mysql-server
[root@mylove ~]# rpm -ivh MySQL-server-5.6.26-1.linux_glibc2.5.x86_64.rpm

(5) 查看数据库初始密码
[ ] cat /root/.mysql_secret 查看初始密码
4. 安装mysql的客户端包：
[root@mylove ~]# rpm -ivh MySQL-client-5.6.26-1.linux_glibc2.5.x86_64.rpm
5. 启动mysql的服务端：
[root@mylove ~]# service mysql start
Starting MySQL. SUCCESS!
6. 修改root的初始密码：
[root@mylove ~]# /usr/bin/mysql_secure_installation 按提示
7. 测试：
用mysql命令行客户端登陆mysql服务器看能否成功
[root@mylove ~]# mysql -uroot -proot
mysql> show databases;
8. 给root用户授予从任何机器上登陆mysql服务器的权限：
mysql> grant all privileges on . to ‘root’@’%’ identified by ‘你的密码’ with grant option;
Query OK, 0 rows affected (0.00 sec)
mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)
注意点: 要让mysql可以远程登录访问
最直接测试方法: 从windows上用Navicat去连接，能连，则可以，不能连，则要去mysql的机器上用命令行客户端进行授权：
在mysql的机器上,启动命令行客户端：
mysql -uroot -proot
mysql>grant all privileges on . to ‘root’@’%’ identified by ‘root的密码’ with grant option;
mysql>flush privileges;

退出sql命令客户端:
mysql> quit;

Bye

MYSQL(集群安装)

#首先在node-1、node-2、node-3上安装MySQL
#配置MySQL 5.7的yum源
[ ] sudo tee -a /etc/yum.repos.d/mysql-community.repo << EOF
[mysql57-community]

name=MySQL 5.7 Community Server
baseurl=http://repo.mysql.com/yum/mysql-5.7-community/el/6/$basearch/
enabled=1
gpgcheck=0
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-mysql
EOF

#查看mysql源的信息
[ ] yum repolist enabled | grep mysql

#安装mysql的server
[ ] sudo yum install -y mysql-community-server

#启动mysql
[ ] sudo service mysqld start

#获取启动日志中的默认初始密码
#sudo grep ‘temporary password’ /var/log/mysqld.log

#获取密码并赋给一个变量

PASSWORD=`sudo grep ‘temporary password’ /var/log/mysqld.log | awk ‘{print $NF}’`

#使用root用户登录
[ ] mysql -uroot -p$PASSWORD

#修改root用户的密码
[ ] ALTER USER ‘root’@‘localhost’ IDENTIFIED BY ‘XiaoNiu_123!’;

#修改mysql远程登录权限
[ ] GRANT ALL PRIVILEGES ON . TO ‘root’@’%’ IDENTIFIED BY ‘XiaoNiu_123!’ WITH GRANT [ ] OPTION;
[ ] FLUSH PRIVILEGES;

#然后在node-4安装JDK并配置环境变量
#然后在node-4安装mycat
#上传Mycat-server-1.6.5-release-20171008170112-linux.tar.gz安装包
#修改conf目录下主要以下三个注意配置文件
server.xml是Mycat服务器参数调整和用户授权的配置文件
schema.xml是逻辑库定义和表以及分片定义的配置文件
rule.xml是分片规则的配置文件

#修改server.xml(修改了mycat的用户和逻辑的database)

<user name="xiaoniu" defaultAccount="true">
        <property name="password">123456</property>
        <property name="schemas">bigdata</property>
</user>

<user name="user">
        <property name="password">user</property>
        <property name="schemas">bigdata</property>
        <property name="readOnly">true</property>
</user>

#修改schema.xml（配置逻辑库下的逻辑表，已经数据存放的mysql节点）

  <schema name="bigdata" checkSQLschema="false" sqlMaxLimit="100">
        <!-- auto sharding by id (long) -->
        <table name="travelrecord" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />
        <!-- global table is auto cloned to all defined data nodes ,so can join
            with any table whose sharding node is in the same data node -->
        <table name="company" primaryKey="ID" type="global" dataNode="dn1,dn2,dn3" />
        <!-- random sharding using mod sharind rule -->
        <table name="hotnews" primaryKey="ID" autoIncrement="true" dataNode="dn1,dn2,dn3"
               rule="mod-long" />
    </schema>

    <dataNode name="dn1" dataHost="node1" database="db1" />
    <dataNode name="dn2" dataHost="node2" database="db2" />
    <dataNode name="dn3" dataHost="node3" database="db3" />

    <dataHost name="node1" maxCon="1000" minCon="10" balance="0"
              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
        <heartbeat>select user()</heartbeat>
        <!-- can have multi write hosts -->
        <writeHost host="hostM1" url="192.168.10.101:3306" user="root" password="XiaoNiu_123!">
        </writeHost>
</dataHost>

    <dataHost name="node2" maxCon="1000" minCon="10" balance="0"
              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
        <heartbeat>select user()</heartbeat>
        <!-- can have multi write hosts -->
        <writeHost host="hostM1" url="192.168.10.102:3306" user="root" password="XiaoNiu_123!">
        </writeHost>
</dataHost>

    <dataHost name="node3" maxCon="1000" minCon="10" balance="0"
              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
        <heartbeat>select user()</heartbeat>
        <!-- can have multi write hosts -->
        <writeHost host="hostM1" url="192.168.10.103:3306" user="root" password="XiaoNiu_123!">
        </writeHost>
    </dataHost>

#在三台mysql上分别创建数据库db1、db2、db3
#然后在每一个database中创建表，有三张（travelrecord、company、hotnews）注意主键的名称
#在node-4上启动mycat

mysql -h 192.168.10.104 -P 8066 -u root -p123456

---

HIVE

1.上传压缩包apache-hive-1.2.1-bin.tar.gz
2.解压
[ ] tar -zxvf apache-hive-1.2.1-bin.tar.gz -C /root/hadoop
3.创建配置文件hive-site.xml

<configuration>
<property>
<name>javax.jdo.option.ConnectionURL</name>
<value>jdbc:mysql://node8:3306/hive?createDatabaseIfNotExist=true</value>
<description>JDBC connect string for a JDBC metastore</description>
</property>

<property>
<name>javax.jdo.option.ConnectionDriverName</name>
<value>com.mysql.jdbc.Driver</value>
<description>Driver class name for a JDBC metastore</description>
</property>

<property>
<name>javax.jdo.option.ConnectionUserName</name>
<value>root</value>
<description>username to use against metastore database</description>
</property>

<property>
<name>javax.jdo.option.ConnectionPassword</name>
<value>123456</value>
<description>password to use against metastore database</description>
</property>
</configuration>

4.传一个mysql的驱动jar包到hive的安装目录的lib中
5.配置HADOOP_HOME 和HIVE_HOME到系统环境变量中：/etc/profile
6.source /etc/profile
7.hive启动测试
然后用命令启动hive交互界面：
[root@hdp20-04 ~]# hive
8. 基本使用方式
启动一个hive交互shell
[ ] bin/hive

hive>

设置一些基本参数，让hive使用起来更便捷，比如：
1、让提示符显示当前库：
hive>set hive.cli.print.current.db=true;
2、显示查询结果时显示字段名称：
hive>set hive.cli.print.header=true;

但是这样设置只对当前会话有效，重启hive会话后就失效，解决办法：
在linux的当前用户目录中，编辑一个.hiverc文件，将参数写入其中：
[ ] vi .hiverc

set hive.cli.print.header=true;
set hive.cli.print.current.db=true;

9.启动hive服务使用
启动hive的服务：
[]# bin/hiveserver2 -hiveconf hive.root.logger=DEBUG,console

上述启动，会将这个服务启动在前台，如果要启动在后台，则命令如下：
[ ] nohup bin/hiveserver2 1>/dev/null 2>&1 &

启动成功后，可以在别的节点上用beeline去连接
方式（1）
[root@hdp20-04 hive-1.2.1]# bin/beeline 回车，进入beeline的命令界面
输入命令连接hiveserver2
beeline> !connect jdbc:hive2//mini1:10000
（hadoop01是hiveserver2所启动的那台主机名，端口默认是10000）
方式（2）
启动时直接连接：
[ ] bin/beeline -u jdbc:hive2://192.168.1.139:10000 -n root

重点:
将hive运行在yarn集群上的的方法

1. cd /apps/hadoop-2.8.4/etc/Hadoop/
2. vi mapred-site.xml
3. 修改maperd.framework.name的值为yarn(或local)
   mapred-site.xml:

<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
</configuration>

接下来就可以做正常sql查询了
10.脚本化运行
大量的hive查询任务，如果用交互式shell来进行输入的话，显然效率及其低下，因此，生产中更多的是使用脚本化运行机制：
该机制的核心点是：hive可以用一次性命令的方式来执行给定的hql语句

[root@hdp20-04 ~]# hive -e “insert into table t_dest select * from t_src;”

然后，进一步，可以将上述命令写入shell脚本中，以便于脚本化运行hive任务，并控制、调度众多hive任务，示例如下：
[ ] vi t_order_etl.sh

#!/bin/bash
hive -e "select * from db_order.t_order"
hive -e "select * from default.t_user"
hql="create table  default.t_bash as select * from db_order.t_order"
hive -e "$hql"

如果要执行的hql语句特别复杂，那么，可以把hql语句写入一个文件：
[ ] vi x.hql

select * from db_order.t_order;
select count(1) from db_order.t_user;

然后，用hive -f /root/x.hql 来执行;

11.附加

配置hive数据仓库

1. 说明
   因为使用json格式存放数据，需要第三方serde库。
   下载json-serde-1.3.8-jar-with-dependencies.jar
2. 部署以上的jar包hive的lib下。
3. 配置hive-site.xml文件，添加jar包的声明，永久注册。
   [hive-site.xml]

       <property>
			<name>hive.aux.jars.path</name>
			<value>file:///root/hadoop/hive-1.2.1/lib/json-serde-1.3.8-jar-with-dependencies.jar</value>
		</property>

4. 设置不压缩存储
   [hive-site.xml]

       <property>
			<name>hive.exec.compress.output</name>
			<value>false</value>
		</property>

5. 创建数据库
   $hive>create database applogs_db;

---

HBASE

前言:
首先，要有一个HDFS集群，并正常运行； regionserver应该跟hdfs中的datanode在一起
其次，还需要一个zookeeper集群，并正常运行
然后，安装HBASE

角色分配如下：
Hdp01: namenode datanode regionserver hmaster zookeeper
Hdp02: datanode regionserver zookeeper
Hdp03: datanode regionserver zookeeper

1.上传hbase安装包

2.解压

3. 配置hbase集群

要修改3个文件（首先zk集群已经安装好了）
注意：要把hadoop的hdfs-site.xml和core-site.xml 放到hbase/conf下
[ ] cp hdfs-site.xml /root/hadoop/hbase-1.2.1/conf
[ ] cp core-site.xml /root/hadoop/hbase-1.2.1/conf

3.1修改hbase-env.sh

export JAVA_HOME=/usr/java/jdk1.7.0_55
//告诉hbase使用外部的zk
export HBASE_MANAGES_ZK=false

3.2 修改hbase-site.xml
[ ] vi hbase-site.xml

<configuration>
<!-- 指定hbase在HDFS上存储的路径 -->
<property>
<name>hbase.rootdir</name>
<value>hdfs://node6:9000/hbase</value>
</property>
<!-- 指定hbase是分布式的 -->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<!-- 指定zk的地址，多个用“,”分割 -->
<property>
<name>hbase.zookeeper.quorum</name>
<value>node6:2181,node7:2181,node8:2181</value>
</property>
</configuration>

3.3 修改regionservers
注意: regionserver应该跟hdfs中的datanode在一起
[ ] vi regionservers

node6
node7
node8

3.4拷贝hbase到其他节点
[ ] scp -r /root/hadoop/hbase-1.2.1 node7:/root/hadoop/

4.将配置好的HBase拷贝到每一个节点并同步时间

[ ] date -s ‘2018-10-19 14:43:30’
[ ] hwclock -w

5.启动所有的hbase

5.1首先启动HDFS----查看hdfs集群的状态命令： hdfs dfsadmin -report
##HDFS集群不能处于safe mode状态

5.2分别启动zookeeper
[ ] ./zkServer.sh start
检查保证zk工作状态正常： 检查状态的命令： bin/zkServer.sh status

5.3启动集群
[ ] bin/start-hbase.sh
启动完后，还可以在集群中找任意一台机器启动一个备用的master
[ ] bin/hbase-daemon.sh start master
新启的这个master会处于backup状态

6.通过浏览器访问hbase管理页面

192.168.1.139:16010

16010为默认端口
在hbase-site.xml中加入:

<property>
        <name>hbase.master.info.port</name>
        <value>60010</value>
 </property>

可以指定web访问端口

7.启动hbase的命令行客户端

[ ] bin/hbase shell
Hbase> list // 查看表
Hbase> status // 查看集群状态
Hbase> version // 查看集群版本

---

MongoDB(单机安装)

1. 添加普通用户

#创建一个普通用户xiaoniu
[ ] useradd xiaoniu
#为hadoop用户添加密码：
[ ] echo 123456 | passwd --stdin xiaoniu
#将bigdata添加到sudoers
[ ] echo “lic ALL = (root) NOPASSWD:ALL” | tee /etc/sudoers.d/lic
[ ] chmod 0440 /etc/sudoers.d/lic
#解决sudo: sorry, you must have a tty to run sudo问题，在/etc/sudoer注释掉 Default requiretty 一行
[ ] sudo sed -i ‘s/Defaults requiretty/Defaults:lic !requiretty/’ /etc/sudoers

2.配置mongo的yum源

#配置mongo的yum源
[ ] sodu vi /etc/yum.repos.d/mongodb-org-3.4.repo

[mongodb-org-3.4]

name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.4/x86_64/
gpgcheck=1 enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc

#关闭selinux
[ ] vi /etc/sysconfig/selinux

SELINUX=disabled

#重新启动
[ ] reboot

3.安装单机版mongoDB

#在机器上使用xiaoniu用户登录（本地安装给你了rpm包，rpm -ivh *.rpm）
[ ] sudo yum install -y mongodb-org

#修改mongo的配置文件
[ ] sudo vi /etc/mongod.conf
#注释掉bindIp或者修改成当前机器的某一个ip地址
#启动mongo
[ ] sudo service mongod start
#连接到mongo
#如果注释掉了bindIp，那么连接时用
[ ] mongo
#指定了ip地址
[ ] mongo --host 192.168.100.101 --port 27017
#使用或创建database
[ ] use xiaoniu
#创建集合（表）
[ ] db.createCollection(“bike”)
#插入数据
[ ] db.bike.insert({"_id": 100001, “status”: 1, “desc”: “test”})
[ ] db.bike.insert({"_id": 100002, “status”: 1, “desc”: “test”})
#查找数据(所有)
[ ] db.bine.find()
#退出
[ ] exit

#关闭mongo服务
[ ] sudu service mongod stop
#设置服务开机启动
[ ] sudo chkconfig mongod on
#设置mongo服务开机不启动
[ ] sudo chkconfig mongod off

4.修改mongo的数据库存储路径

#修改mongo的数据库存储路径
[ ] mkdir /root/mongo
[ ] vi /etc/mongod.conf

dbPath: /mongo

#如果修改了mongo存储是的目录那么一定要修改该目录的所属用户和组为mongod
#chown -R mongod:mongod /mongo/

5.添加管理员用户和普通用户

#添加管理员用户
#使用admin这个database
[ ] use admin

#在没有开启认证的情况下，创建一个超级用户

db.createUser(
{
user: “root”,
pwd: “123456”,
roles: [ {role: “root”, db: “admin” }]
}
)

#修改mongo的配置文件/etc/mongod.conf，配置mongo的安全认证
security:
authorization: enabled
#重启mongo服务
[ ] service mongod restart
#重新使用mongo shell连接
[ ] mongo
#使用admin database
[ ] use admin
#授权登录
[ ] db.auth(“root”, “123456”)
#创建一个bike数据库
[ ] use bike
#添加一个普通用户，具备读写权限

db.createUser(
{
user: “lic”,
pwd: “123456”,
roles: [“readWrite”]
}
)

#使用小牛用户登录
[ ] mongo
[ ] use bike
[ ] db.auth(“lic”, “123568”)
#在database下创建collection
[ ] db.createCollection(“users”)
[ ] db.createCollection(“bikes”)
#插入数据
[ ] db.users.insert( { name: “laozhao”, age: 30 }
#查找
[ ] db.users.find()
[ ] db.users.update({‘name’:‘laozhao’},{$set:{‘age’: 18}},{multi:true})
[ ] db.users.remove({‘name’: ‘laoduan’})
[ ] db.users.remove({‘name’: ‘laoduan’}, 1)
[ ] db.users.find({“name”:“laoduan”, “fv”: 99.99})
#查看当前db的索引
[ ] db.logs.getIndexes()
#创建索引
[ ] db.logs.ensureIndex({“name”:1})
#删除索引
[ ] db.logs.dropIndex({“name”:1})

6.备注信息:

#开启运行用户从其他机器连接mongodb
#不然会报错Caused by: java.net.ConnectException: Connection refused (Connection refused)
#修改/etc/mongod.conf，注释掉bindIp:
#bindIp:
#重启mongodb
[ ] service mongod restart

数据库用户角色：read、readWrite;
数据库管理角色：dbAdmin、dbOwner、userAdmin；
集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；
备份恢复角色：backup、restore；
所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
超级用户角色：root
// 这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）
内部角色：__system
每个数据库有相应的普通用户,每个普通用户只在所属的数据库中有对应的读写权限,在其他的数据库中没有读写权限

MongoDB(集群安装)

1. 准备工作

###在多台机器上执行下面的命令
#在所有创建一个lic普通用户：
[ ] useradd lic
#为lic用户添加密码：
[ ] echo 123456 | passwd --stdin lic
#将lic添加到sudoers
[ ] echo “lic ALL = (root) NOPASSWD:ALL” | tee /etc/sudoers.d/lic
[ ] chmod 0440 /etc/sudoers.d/lic
#解决sudo: sorry, you must have a tty to run sudo问题，在/etc/sudoer注释掉 Default requiretty 一行
[ ] sudo sed -i ‘s/Defaults requiretty/Defaults:lic !requiretty/’ /etc/sudoers

#创建一个mongo目录
[ ] mkdir /mongo
#给相应的目录添加权限
[ ] chown -R lic:lic /mongo

#配置mongo的yum源
[ ] cat >> /etc/yum.repos.d/mongodb-org-3.4.repo << EOF
[mongodb-org-3.4]

name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/\$releasever/mongodb-org/3.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc
EOF

#关闭selinux
[ ] sed -i ‘s/SELINUX=enforcing/SELINUX=disabled/’ /etc/selinux/config

#重新启动
[ ] reboot

#分别在多台机器上使用lic用户登录
[ ] sudo yum install -y mongodb-org
本地安装:sudo rpm -ivh *.rpm

#角色信息

node-1        node-2           node-3
mongos        mongos           mongos        路由服务器，寻址
config        config           config        配置服务器，保存配置
shard1(主)    shard2(主)       shard3(主)    分片：保存数据
shard2        shard3           shard1        副本集：备份数据，可以配置读写分离（主负责写，从负责同步数据和读）
shard3        shard1           shard2

2. mongo config server配置

#分别在多台机器上创建mongo config server对应的目录
mkdir -p /mongo/config/{log,data,run}

#分别在多台机器上修改config server的配置文件
[ ] cat >> /mongo/config/mongod.conf << EOF

systemLog:
  destination: file
  logAppend: true
  path: /mongo/config/log/mongod.log
storage:
  dbPath: /mongo/config/data
  journal:
    enabled: true
processManagement:
  fork: true
  pidFilePath: /mongo/config/run/mongod.pid
net:
  port: 27100
replication:
  replSetName: config
sharding:
  clusterRole: configsvr
EOF

#clusterRole: configsvr这个配置是固定的
#【重要】启动所有的mongo config server服务
#ps -ef | grep mongo 查看进程
[ ] mongod --config /mongo/config/mongod.conf

#登录任意一台配置服务器，初始化配置副本集
[ ] mongo --port 27100

#创建配置

config = {
   _id : "config",
    members : [
        {_id : 0, host : "192.168.1.166:27100" },
        {_id : 1, host : "192.168.1.167:27100" },
        {_id : 2, host : "192.168.1.139:27100" }
    ]
}

#初始化副本集配置
rs.initiate(config)

#查看分区状态
rs.status()
#注意:其中，"_id" : "config"对应配置文件中配置的 replicaction.replSetName 一致，“members” 中的 “host” 为三个节点的ip和port

3_1. mongo shard1 server配置

#配置第一个分片和副本集
#修改mongo shard1 server的配置文件
[ ] mkdir -p /mongo/shard1/{log,data,run}

#分别在多台机器上修改shard1 server的配置文件
[ ] cat >> /mongo/shard1/mongod.conf << EOF

systemLog:
  destination: file
  logAppend: true
  path: /mongo/shard1/log/mongod.log
storage:
  dbPath: /mongo/shard1/data
  journal:
    enabled: true
processManagement:
  fork: true
  pidFilePath: /mongo/shard1/run/mongod.pid
net:
  port: 27001
replication:
  replSetName: shard1
sharding:
  clusterRole: shardsvr
EOF

#启动所有的shard1 server
[ ] mongod --config /mongo/shard1/mongod.conf
#登陆任意一台shard1服务器(希望哪一台机器是主,就登录到那一台机器上)，初始化副本集
[ ] mongo --port 27001
#使用admin数据库
[ ] use admin
#定义副本集配置

config = {
   _id : "shard1",
    members : [
        {_id : 0, host : "192.168.1.166:27001" },
        {_id : 1, host : "192.168.1.167:27001" },
        {_id : 2, host : "192.168.1.139:27001" }
    ]
}

#初始化副本集配置
[ ] rs.initiate(config);

#查看分区状态
[ ] rs.status()

3_2. mongo shard2 server配置

#配置第二个分片和副本集
#修改mongo shard2 server的配置文件
[ ] mkdir -p /mongo/shard2/{log,data,run}

#分别在多台机器上修改shard2 server的配置文件
[ ] cat >> /mongo/shard2/mongod.conf << EOF

systemLog:
  destination: file
  logAppend: true
  path: /mongo/shard2/log/mongod.log
storage:
  dbPath: /mongo/shard2/data
  journal:
    enabled: true
processManagement:
  fork: true
  pidFilePath: /mongo/shard2/run/mongod.pid
net:
  port: 27002
replication:
  replSetName: shard2
sharding:
  clusterRole: shardsvr
EOF

#启动所有的shard2 server
[ ] mongod --config /mongo/shard2/mongod.conf

#登陆(node2)的shard2服务器，初始化副本集
[ ] mongo --port 27002
#使用admin数据库
[ ] use admin
#定义副本集配置

config = {
   _id : "shard2",
    members : [
        {_id : 0, host : "192.168.1.166:27002" },
        {_id : 1, host : "192.168.1.167:27002" },
        {_id : 2, host : "192.168.1.139:27002" }
    ]
}

#初始化副本集配置
[ ] rs.initiate(config)

#查看分区状态
[ ] rs.status()

3_3. mongo shard3 server配置

#配置第三个分片和副本集
#修改mongo shard3 server的配置文件
[ ] mkdir -p /mongo/shard3/{log,data,run}

#分别在多台机器上修改shard3 server的配置文件
[ ] cat >> /mongo/shard3/mongod.conf << EOF

systemLog:
  destination: file
  logAppend: true
  path: /mongo/shard3/log/mongod.log
storage:
  dbPath: /mongo/shard3/data
  journal:
    enabled: true
processManagement:
  fork: true
  pidFilePath: /mongo/shard3/run/mongod.pid
net:
  port: 27003
replication:
  replSetName: shard3
sharding:
  clusterRole: shardsvr
EOF

#启动所有的shard3 server
[ ] mongod --config /mongo/shard3/mongod.conf

#登陆node-1上的shard3服务器，初始化副本集
[ ] mongo --port 27003
#使用admin数据库
[ ] use admin
#定义副本集配置

config = {
   _id : "shard3",
    members : [
        {_id : 0, host : "192.168.1.166:27003" },
        {_id : 1, host : "192.168.1.167:27003" },
        {_id : 2, host : "192.168.1.139:27003" }
    ]
}

#初始化副本集配置
[ ] rs.initiate(config)

#查看分区状态
[ ] rs.status()

4. mongos 配置

#注意：启动mongos是守候进程是因为/mongo/mongos/mongod.conf缺少了fork: true这个配置###
[ ] mkdir -p /mongo/mongos/{log,data,run}

#添加mongs的配置文件
[ ] cat >> /mongo/mongos/mongod.conf << EOF

systemLog:
  destination: file
  logAppend: true
  path: /mongo/mongos/log/mongod.log
processManagement:
  fork: true
  pidFilePath: /mongo/mongos/run/mongod.pid
net:
  port: 27200
sharding:
  configDB: config/192.168.1.166:27100,192.168.1.167:27100,192.168.1.139:27100
EOF

#注意，这里configDB后面的config要与配置服务器的_id保持一致

#启动路由服务器
[ ] mongos --config /mongo/mongos/mongod.conf

#登录其中的一台路由节点，手动启用分片
[ ] mongo --port 27200

#添加分片到mongos
[ ] sh.addShard(“shard1/192.168.1.166:27001,192.168.1.167:27001,192.168.1.139:27001”)
[ ] sh.addShard(“shard2/192.168.1.167:27002,192.168.1.139:27002,192.168.1.166:27002”)
[ ] sh.addShard(“shard3/192.168.1.139:27003,192.168.1.166:27003,192.168.1.167:27003”)

#设置slave可读(在命令行中生效一次)，如果配置从接到可读，那么是连接客户端指定的
[ ] rs.slaveOk()

###没有分片是因为没有开启分片规则###
#创建mobike数据库
[ ] use admin

#创建mobike数据库

#对bikes这个数据库开启分片功能
[ ] db.runCommand({“enablesharding”:“mobike”})

#创建bikes集合
[ ] db.createCollection(“bikes”)

##对bike数据库下的users集合按id的hash进行分片
[ ] db.runCommand({“shardcollection”:“mobike.bikes”,“key”:{_id:‘hashed’}})

#启动所有的config server
[ ] mongod --config /mongo/config/mongod.conf
#启动所有的shard1
[ ] mongod --config /mongo/shard1/mongod.conf
#启动所有的shard2
[ ] mongod --config /mongo/shard2/mongod.conf
#启动所有的shard3
[ ] mongod --config /mongo/shard3/mongod.conf
#启动所有的mongos
[ ] mongos --config /mongo/mongos/mongod.conf

#关闭服务
[ ] mongod --shutdown --dbpath /mongo/shard3/data
[ ] mongod --shutdown --dbpath /mongo/shard2/data
[ ] mongod --shutdown --dbpath /mongo/shard1/data
[ ] mongod --shutdown --dbpath /mongo/config/data