大数据技术栈_数据库(Mysql、Hive、Hbase、MongoDB、Redis)环境搭建
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)
123456
bigdata
user
bigdata
true
#修改schema.xml（配置逻辑库下的逻辑表，已经数据存放的mysql节点）
select user()
select user()
select user()
#在三台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
javax.jdo.option.ConnectionURL
jdbc:mysql://node8:3306/hive?createDatabaseIfNotExist=true
JDBC connect string for a JDBC metastore
javax.jdo.option.ConnectionDriverName
com.mysql.jdbc.Driver
Driver class name for a JDBC metastore
javax.jdo.option.ConnectionUserName
root
username to use against metastore database
javax.jdo.option.ConnectionPassword
123456
password to use against metastore database
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集群上的的方法
- cd /apps/hadoop-2.8.4/etc/Hadoop/
- vi mapred-site.xml
- 修改maperd.framework.name的值为yarn(或local)
mapred-site.xml:
mapreduce.framework.name
yarn
接下来就可以做正常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数据仓库
- 说明
因为使用json格式存放数据，需要第三方serde库。
下载json-serde-1.3.8-jar-with-dependencies.jar - 部署以上的jar包hive的lib下。
- 配置hive-site.xml文件，添加jar包的声明，永久注册。
[hive-site.xml]
hive.aux.jars.path
file:///root/hadoop/hive-1.2.1/lib/json-serde-1.3.8-jar-with-dependencies.jar
- 设置不压缩存储
[hive-site.xml]
hive.exec.compress.output
false
- 创建数据库
$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
hbase.rootdir
hdfs://node6:9000/hbase
hbase.cluster.distributed
true
hbase.zookeeper.quorum
node6:2181,node7:2181,node8:2181
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中加入:
hbase.master.info.port
60010
可以指定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
Redis
Redis是目前一个非常优秀的key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set有序集合)和hash（哈希类型）。
一、Redis3单机安装
参考文章：http://blog.csdn.net/myrainblues/article/details/25881535
1.下载redis3的稳定版本，下载地址
2. 上传redis-3.2.11.tar.gz到服务器
3.解压redis源码包
[ ] tar -zxvf redis-3.2.11.tar.gz -C /usr/local/src/
4.进入到源码包中，编译并安装redis
[ ] cd /usr/local/src/redis-3.2.11/
[ ] make && make install
5.报错，缺少依赖的包
[ ] 缺少gcc依赖（c的编译器）
6.配置本地YUM源并安装redis依赖的rpm包
[ ] yum -y install gcc
7.编译并安装
[ ] make && make install
8.报错，原因是没有安装jemalloc内存分配器，可以安装jemalloc或直接输入
[ ] make MALLOC=libc && make install
9.重新编译安装
[ ] make MALLOC=libc && make install
10.在所有机器的/usr/local/下创建一个redis目录，然后拷贝redis自带的配置文件redis.conf到/usr/local/redis
[ ] mkdir /usr/local/redis
[ ] cp /usr/local/src/redis-3.2.11/redis.conf /usr/local/redis
11.修改所有机器的配置文件redis.conf
[ ] daemonize yes #redis后台运行
[ ] appendonly yes #开启aof日志，它会每次写操作都记录一条日志
[ ] bind 192.168.1.207
12.启动所有的redis节点
[ ] cd /usr/local/redis
[ ] redis-server redis.conf
13.查看redis进程状态
[ ] ps -ef | grep redis
14.使用命令行客户的连接redis
[ ] redis-cli -p 6379
15.关闭redis
[ ] redis-cli shutdown
17.配置redis密码
[ ] config set requirepass 123
18.添加redis的java依赖
redis.clients
jedis
2.9.0
java操作Redis：Jedis
http://blog.csdn.net/xyang81/article/details/51918129
二、Redis3集群安装(6台linux服务器)
参考文章：http://blog.csdn.net/myrainblues/article/details/25881535
1.下载redis3的稳定版本，下载地址
2.上传redis-3.2.10.tar.gz到服务器
3.解压redis源码包
[ ] tar -zxvf redis-3.2.10.tar.gz -C /usr/local/src/
4.进入到源码包中，编译并安装redis
[ ] cd /usr/local/src/redis-3.2.10/
[ ] make && make install
5.报错，缺少依赖的包
6.配置本地YUM源并安装redis依赖的rpm包
[ ] yum -y install gcc
7.编译并安装
[ ] make && make install
8.报错，原因是没有安装jemalloc内存分配器，可以安装jemalloc或直接输入
9.重新编译安装
[ ] make MALLOC=libc && make install
10.用同样的方式在其他的机器上编译安装redis
11.在所有机器的/usr/local/下创建一个redis目录，然后拷贝redis自带的配置文件redis.conf到/usr/local/redis
[ ] mkdir /usr/local/redis
[ ] cp /usr/local/src/redis-3.2.10/redis.conf /usr/local/redis
12.修改所有机器的配置文件redis.conf
daemonize yes #redis后台运行
cluster-enabled yes #开启集群把注释去掉 appendonly
yes #开启aof日志，它会每次写操作都记录一条日志
[ ] sed -i ‘s/daemonize no/daemonize yes/’ /usr/local/redis/redis.conf
[ ] sed -i “s/bind 127.0.0.1/ bind 192.168.1.166/” /usr/local/redis/redis.conf
[ ] sed -i ‘s/# cluster-enabled yes/cluster-enabled yes/’ /usr/local/redis/redis.conf
[ ] sed -i ‘s/appendonly no/appendonly yes/’ /usr/local/redis/redis.conf
[ ] sed -i ‘s/# cluster-node-timeout 15000/cluster-node-timeout 5000/’ /usr/local/redis/redis.conf
13.启动所有的redis节点
[ ] cd /usr/local/redis
[ ] redis-server redis.conf
14.查看redis进程状态
[ ] ps -ef | grep redis
15.（只要在一台机器上安装即可）配置集群：安装ruby和ruby gem工具（redis3集群配置需要ruby的gem工具，类似yum）
[ ] yum -y install ruby rubygems
16.使用gem下载redis集群的配置脚本
[ ] gem install redis
[ ] ruby --version
17.安装RVM
[ ] curl -sSL https://rvm.io/mpapis.asc | gpg2 --import
[ ] curl -L get.rvm.io | bash -s stable
[ ] source /usr/local/rvm/scripts/rvm
[ ] rvm list known
[ ] rvm install 2.3.4
#用ruby的工具安装reids
[ ] gem install redis
18.使用脚本配置redis集群(前提redis各个节点处于开启状态,且至少需要6台liunx服务器)
[ ] cd /usr/local/src/redis-3.2.10/src/
#service iptables stop
#在第一机器上执行下面的命令(部署redis集群:指定主从以及备份数量)
[ ] ./redis-trib.rb create --replicas 1 192.168.1.166:6379 192.168.1.167:6379 192.168.1.139:6379 192.168.1.191:6379 192.168.1.139:6379 192.168.1.191:6379
19.测试(别忘加-c参数)
[ ] redis-cli -c -h 192.168.1.13
三、Redis3伪分布式安装
1.下载redis3的稳定版本, 下载地址
2.上传redis-3.2.10.tar.gz到服务器
3.解压redis源码包
[ ] tar -zxvf redis-3.2.10.tar.gz -C /usr/local/src/
4.进入到源码包中，编译并安装redis
[ ] cd /usr/local/src/redis-3.2.10/
[ ] make && make install
5.在/usr/local/下创建一个redis目录，然后分别在/usr/local/redis目录创建6个文件夹7000,7001,7002,7003,7004,7005然后拷贝redis自带的配置文件redis.conf到这六个目录中
[ ] mkdir /usr/local/redis
[ ] mkdir /usr/local/redis/{7000,7001,7002,7003,7004,7005}
[ ] cp /usr/local/src/redis-3.2.10/redis.conf /usr/local/redis/7000
[ ] cp /usr/local/src/redis-3.2.10/redis.conf /usr/local/redis/7001
[ ] cp /usr/local/src/redis-3.2.10/redis.conf /usr/local/redis/7002
[ ] cp /usr/local/src/redis-3.2.10/redis.conf /usr/local/redis/7003
[ ] cp /usr/local/src/redis-3.2.10/redis.conf /usr/local/redis/7004
[ ] cp /usr/local/src/redis-3.2.10/redis.conf /usr/local/redis/7005
6.分别修改这六个目录中的配置文件
port 7000 #端口要与其所在的文件名一致
pidfile /var/run/redis-7000.pid #pid要与其所在的文件名一致
daemonize yes
cluster-enabled yes
appendonly yes
7.分别进入到这六个目录启动redis进程
[ ] cd /usr/local/redis/7000
[ ] redis-server redis.conf
[ ] cd /usr/local/redis/7001
[ ] redis-server redis.conf
[ ] cd /usr/local/redis/7002
[ ] redis-server redis.conf
[ ] cd /usr/local/redis/7003
[ ] redis-server redis.conf
[ ] cd /usr/local/redis/7004
[ ] redis-server redis.conf
[ ] cd /usr/local/redis/7005
[ ] redis-server redis.conf
HOST=`ifconfig eth1 | grep “inet addr” | awk -F : ‘{print $2}’ | awk ‘{print $1}’`
[ ] sed -i “s/bind 127.0.0.1/bind $HOST/” /usr/local/redis/redis.conf
[ ] redis-server /usr/local/redis/redis.conf
[ ] config set masterauth xiaoniu
[ ] config set requirepass xiaoniu
[ ] config rewrite
[ ] redis-cli -h 192.168.100.101 -a xiaoniu shutdown