环境规划服务器规划
192.168.3.167                    192.168.3.168                    192.168.3.170
mongos                             mongos                              mongos
config server                     config server                       config server
shard server1 主节点         shard server1 副节点           shard server1 仲裁
shard server2 仲裁            shard server2 主节点           shard server2 副节点
shard server3 副节点         shard server3 仲裁              shard server3 主节点
端口分配:
mongos：20000 
config：27017
shard1：27001 
shard2：27002 
shard3：27003
 
配置yum源并安装mongodb3.6

cat > /etc/yum.repos.d/mongodb-org-3.6.repo << EOF

[mongodb-org-3.6]

name=MongoDB Repository

baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.6/x86_64/

gpgcheck=1

enabled=1

gpgkey=https://www.mongodb.org/static/pgp/server-3.6.asc

EOF

​

yum install mongodb-org -y

目录创建:
分别在每台机器建立conf、mongos、config、shard1、shard2、shard3目录，因为mongos不存储数据，只需要建立日志文件目录即可
配置服务:
可以根据业务需求创建相应目录，此文档按yum安装所产生的/etc/mongo.ocnf文件默认配置，如果自行创建记得修改目录权限

chown -R mongod:mongod /var/lib/mongo

vim /etc/mongod.conf

systemLog:

  destination: file

  logAppend: true

  path: /var/log/mongodb/mongod.log

storage:

  dbPath: /var/lib/mongo

  journal:

    enabled: true

processManagement:

  fork: true  # fork and run in background

  pidFilePath: /var/run/mongodb/mongod.pid  # location of pidfile

  timeZoneInfo: /usr/share/zoneinfo

net:

  port: 27017

  bindIp: 0.0.0.0

replication:

  replSetName: csReplSet

sharding:

  clusterRole: configsvr  

启动所有的mongo config server服务

mongod --config /etc/mongod.conf

 副本服务登录任意一台配置服务器，初始化配置副本集

mongo --port 27017

#创建配置

config = {

  _id : "csReplSet", 

  members : [ 

  {_id : 1, host : "192.168.3.167:27017" }, 

  {_id : 2, host : "192.168.3.168:27017" }, 

  {_id : 3, host : "192.168.3.170:27017" } 

  ] 

}

#初始化副本集

rs.initiate(config)

#查看状态

rs.status()

其中，"_id" : " csReplSet "应与配置文件中配置的 replicaction.replSetName 一致，"members" 中的 "host" 为三个节点的 ip 和 port
 
分片服务:
配置分片副本集(三台机器)
1.设置第一个分片副本集

vim /etc/shard1.conf

systemLog:

  destination: file

  logAppend: true

  path: /var/log/mongodb/shard1.log

storage:

  dbPath: /var/lib/mongo/shard1/data

  journal:

    enabled: true

processManagement:

  fork: true

  pidFilePath: /var/run/mongodb/shard1.pid

  timeZoneInfo: /usr/share/zoneinfo

net:

  port: 27001

  bindIp: 0.0.0.0

  maxIncomingConnections: 20000

replication:

  replSetName: shard1

sharding:

  clusterRole: shardsvr

  

#启动所有的shard1 server

mongod --config /etc/shard1.conf

​

#登陆任意一台shard1服务器，初始化副本集

mongo --port 27001

use admin

#定义副本集配置

config = {

   _id : "shard1",

    members : [

        {_id : 1, host : "192.168.3.167:27001",priority:2 },

        {_id : 2, host : "192.168.3.168:27001",priority:1 },

        {_id : 3, host : "192.168.3.170:27001",arbiterOnly: true }

    ]

}

#初始化副本集配置

rs.initiate(config);

​

#查看分区状态

rs.status()

​

====================

#配置第二个分片和副本集

vim /etc/shard2.conf

systemLog:

  destination: file

  logAppend: true

  path: /var/log/mongodb/shard2.log

storage:

  dbPath: /var/lib/mongo/shard2/data

  journal:

    enabled: true

processManagement:

  fork: true

  pidFilePath: /var/run/mongodb/shard2.pid

  timeZoneInfo: /usr/share/zoneinfo

net:

  port: 27002

  bindIp: 0.0.0.0

  maxIncomingConnections: 20000

replication:

  replSetName: shard2

sharding:

  clusterRole: shardsvr

  

#启动所有的shard2 server

mongod --config /etc/shard2.conf

​

#登陆任意一台非仲裁节点服务器，初始化副本集

mongo --port 27002

use admin

​

#定义副本集配置

config = {

   _id : "shard2",

    members : [

        {_id : 1, host : "192.168.3.167:27002",arbiterOnly: true },

        {_id : 2, host : "192.168.3.168:27002",priority:2 },

        {_id : 3, host : "192.168.3.170:27002",priority:1 }

    ]

}

#初始化副本集配置

rs.initiate(config);

​

#查看分区状态

rs.status()

​

#配置第三个分片和副本集

vim /etc/shard3.conf

systemLog:

  destination: file

  logAppend: true

  path: /var/log/mongodb/shard3.log

storage:

  dbPath: /var/lib/mongo/shard3/data

  journal:

    enabled: true

processManagement:

  fork: true

  pidFilePath: /var/run/mongodb/shard3.pid

  timeZoneInfo: /usr/share/zoneinfo

net:

  port: 27003

  bindIp: 0.0.0.0

  maxIncomingConnections: 20000

replication:

  replSetName: shard3

sharding:

  clusterRole: shardsvr

  

#启动所有的shard3 server

mongod --config /etc/shard3.conf

​

#初始化副本集配置

rs.initiate(config)

​

#查看分区状态

rs.status()

路由服务:
配置路由服务器 mongos
先启动配置服务器和分片服务器,后启动路由实例启动路由实例:（三台机器）

vim /etc/mongos.conf

systemLog:

  destination: file

  logAppend: true

  path: /var/log/mongodb/mongos.log

processManagement:

  fork: true

  pidFilePath: /var/run/mongodb/mongos.pid

  timeZoneInfo: /usr/share/zoneinfo

net:

  port: 20000

  bindIp: 0.0.0.0

  maxIncomingConnections: 20000

sharding:

  configDB: csReplSet/192.168.3.167:27017,192.168.3.168:27017,192.168.3.170:27017

​

#注意监听的配置服务器,只能有1个或者3个 csReplSet为配置服务器的副本集名字

configDB: csReplSet/192.168.3.167:21000, 192.168.3.168:21000, 192.168.3.170:21000

​

#启动路由服务器

mongos --config /etc/mongos.conf

​

#检查状态

netstat -tunlp | grep mongo

tcp        0      0 0.0.0.0:27001           0.0.0.0:*               LISTEN      8810/mongod     

tcp        0      0 0.0.0.0:27002           0.0.0.0:*               LISTEN      6962/mongod    

tcp        0      0 0.0.0.0:27003           0.0.0.0:*               LISTEN      12671/mongod      tcp        0      0 0.0.0.0:20000           0.0.0.0:*               LISTEN      13577/mongos      tcp        0      0 0.0.0.0:27017           0.0.0.0:*               LISTEN      10328/mongod  

启用分片
目前搭建了mongodb配置服务器、路由服务器，各个分片服务器，不过应用程序连接到mongos路由服务器并不能使用分片机制，还需要在程序里设置分片配置，让分片生效

#登录其中的一台路由节点，手动启用分片

mongo --port 20000

use admin

#添加分片到mongos

sh.addShard("shard1/192.168.3.167:27001,192.168.3.168:27001,192.168.3.170:27001")

sh.addShard("shard2/192.168.3.167:27002,192.168.3.168:27002,192.168.3.170:27002")

sh.addShard("shard3/192.168.3.167:27003,192.168.3.168:27003,192.168.3.170:27003")

​

#查看集群状态

sh.status()

kubeadm手动安装kubernetes 1.13高可用集群
 初始化集群:配置hosts文件
vim /etc/hosts

192.168.3.147test-master01

192.168.3.148test-master02

192.168.3.149test-master03

192.168.3.150test-work01

配置免密登录

ssh-keygen

ssh-copy-id test-master01

ssh-copy-id test-master02

ssh-copy-id test-master03

ssh-copy-id test-work01

设置参数

• 关闭防火墙

systemctl stop firewalldsystemctl disable firewalld

• 关闭swap

swapoff -ased -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

修改 /etc/fstab 文件，注释掉 SWAP 的自动挂载，使用free -m确认swap已经关闭。

• 关闭selinux

sed-i 's/SELINUX=permissive/SELINUX=disabled/' /etc/sysconfig/selinuxsetenforce0

• 配置转发相关参数，否则可能会出错

cat <<EOF > /etc/sysctl.d/k8s.confnet.bridge.bridge-nf-call-ip6tables = 1net.bridge.bridge-nf-call-iptables = 1net.ipv4.ip_forward=1net.ipv4.tcp_tw_recycle=0vm.swappiness=0vm.overcommit_memory=1vm.panic_on_oom=0fs.inotify.max_user_watches=89100fs.file-max=52706963fs.nr_open=52706963net.ipv6.conf.all.disable_ipv6=1net.netfilter.nf_conntrack_max=2310720EOFsysctl --system

以上在所有的Kubernetes节点执行命令使修改生效

• kube-proxy开启ipvs

在所有work节点执行：

cat > /etc/sysconfig/modules/ipvs.modules <<EOF#!/bin/bashmodprobe -- ip_vsmodprobe -- ip_vs_rrmodprobe -- ip_vs_wrrmodprobe -- ip_vs_shmodprobe -- nf_conntrack_ipv4EOFchmod 755 /etc/sysconfig/modules/ipvs.modules && bash /etc/sysconfig/modules/ipvs.modules && lsmod | grep -e ip_vs -e nf_conntrack_ipv4

上面脚本创建了的/etc/sysconfig/modules/ipvs.modules文件，保证在节点重启后能自动加载所需模块。 使用lsmod | grep -e ip_vs -e nf_conntrack_ipv4命令查看是否已经正确加载所需的内核模块.接下来还需要确保各个节点上已经安装了ipset软件包yum install ipset。 为了便于查看ipvs的代理规则，最好安装一下管理工具ipvsadm yum install ipvsadm

yum install ipset -yyum install ipvsadm -y

如果以上前提条件如果不满足，则即使kube-proxy的配置开启了ipvs模式，也会退回到iptables模式

• 系统优化参数

systemctl enable ntpdate.service

echo '*/30 * * * * /usr/sbin/ntpdate time7.aliyun.com >/dev/null 2>&1'> /tmp/crontab2.tmp

crontab /tmp/crontab2.tmp

systemctl start ntpdate.service

echo "* soft nofile 65536" >> /etc/security/limits.conf

echo "* hard nofile 65536" >> /etc/security/limits.conf

echo "* soft nproc 65536"  >>/etc/security/limits.conf

echo "* hard nproc 65536"  >>/etc/security/limits.conf

echo "* soft  memlock  unlimited"  >> /etc/security/limits.conf

echo "* hard memlock unlimited"  >>/etc/security/limits.conf

 安装docker

yum install -y epel-release

yum install -y yum-utils device-mapper-persistent-data lvm2 net-tools conntrack-toolswget vim  ntpdate libseccomp libtool-ltdltelnet rsync bind-utils

yum install -y https://mirrors.aliyun.com/docker-ce/linux/centos/7/x86_64/stable/Packages/docker-ce-18.06.1.ce-3.el7.x86_64.rpm 

配置docker国内镜像:
所有节点安装docker
编辑/etc/docker/daemon.json，添加以下一行

{

"registry-mirrors":["https://registry.docker-cn.com"]

}

重启docker

systemctl daemon-reload

systemctl enable docker

systemctl start docker

注：如果使用overlay2的写法：

daemon.json

{

    "log-driver": "json-file",

    "log-opts": {

        "max-size": "100m",

        "max-file": "10"

    },

    "registry-mirrors": ["https://pqbap4ya.mirror.aliyuncs.com"],

        "storage-driver": "overlay2",

    "storage-opts":["overlay2.override_kernel_check=true"]

}

如果要使用overlay2，前提条件为使用ext4，如果使用xfs，需要格式化磁盘加上参数 mkfs.xfs -n ftype=1 /path/to/your/device ，ftype=1这个参数需要配置为1
 安装keepalived+haproxy
三台master 节点
略
VIP : 192.168.3.80
 安装 kubeadm, kubelet 和 kubectl
所有节点都执行设置yum源

cat <<EOF > /etc/yum.repos.d/kubernetes.repo

[kubernetes]

name=Kubernetes

baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/

enabled=1

gpgcheck=1

repo_gpgcheck=1

gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg

EOF

安装组件

yum install -y kubelet-1.13.1 kubeadm-1.13.1 kubectl-1.13.1

开机启动

systemctl enable kubelet.service

 初始化K8S集群编辑kubeadm配置文件:
下面配置是kubeadm安装etcd写法：

cat > kubeadm-config.yaml << EOF

apiVersion: kubeadm.k8s.io/v1beta1

kind: ClusterConfiguration

kubernetesVersion: v1.13.1

apiServer:

  certSANs:

    - "192.168.3.80"

controlPlaneEndpoint: "192.168.3.80:8443"

networking:

  podSubnet: "10.50.0.0/16"

imageRepository: "harbor.oneitfarm.com/k8s-cluster-images"

EOF

​

CNI使用Calico，设置podSubnet: “10.50.0.0/16”
192.168.3.80是刚才安装haproxy+keepalived的VIP初始化第一个master

kubeadm init --config kubeadm-config.yaml

...

[root@master01 ~]# mkdir -p $HOME/.kube

[root@master01 ~]# cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

[root@master01 ~]# chown $(id -u):$(id -g) $HOME/.kube/config

安装网络插件
按官网方式：
Installing with the Kubernetes API datastore—50 nodes or less：

kubectl apply -f \

https://docs.projectcalico.org/v3.3/getting-started/kubernetes/installation/hosted/rbac-kdd.yaml

​

kubectl apply -f \

https://docs.projectcalico.org/v3.3/getting-started/kubernetes/installation/hosted/kubernetes-datastore/calico-networking/1.7/calico.yaml

以上建议先wget下来，需要根据自己网络修改配置 ：

- name: CALICO_IPV4POOL_CIDR

  value: "10.50.0.0/16"

复制相关文件到其他master节点

ssh root@master02 mkdir -p /etc/kubernetes/pki/etcd

scp /etc/kubernetes/admin.conf root@master02:/etc/kubernetes

scp /etc/kubernetes/pki/{ca.*,sa.*,front-proxy-ca.*} root@master02:/etc/kubernetes/pki

scp /etc/kubernetes/pki/etcd/ca.* root@master02:/etc/kubernetes/pki/etcd

部署master-other
在其它slave节点上执行下面命令，加入集群

kubeadm join 192.168.3.80:8443 --token pv2a9n.uh2yx1082ffpdf7n --discovery-token-ca-cert-hash sha256:872cac35b0bfec28fab8f626a727afa6529e2a63e3b7b75a3397e6412c06ebc5 --experimental-control-plane

kube-proxy开启ipvs
修改ConfigMap的kube-system/kube-proxy中的config.conf，mode: “ipvs”：

kubectl edit configmap kube-proxy -n kube-system

kubectl get pod -n kube-system | grep kube-proxy | awk '{system("kubectl delete pod "$1" -- grace-period=0 --force -n kube-system")}'

 检查测试查看kubernetes集群状态

kubectl get nodes -o wide

kubectl get cs

    NAME                 STATUS    MESSAGE              ERROR

    controller-manager   Healthy   ok

    scheduler            Healthy   ok

    etcd-0               Healthy   {"health": "true"}

查看etcd集群状态
本文通过kubeadm自动安装etcd，也就是docker方式安装的etcd,可以exec进去容器内检查：

kubectl exec -ti -n kube-system etcd-an-master01 sh

/ # export ETCDCTL_API=3

/ # etcdctl --endpoints=https://[127.0.0.1]:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt --key=/etc/kubernetes/pki/etcd/healthcheck-client.key member list

安装失败清理集群
集群初始化如果遇到问题，可以使用下面的命令进行清理：

kubeadm reset

systemctl stop kubelet

systemctl stop docker

rm -rf /var/lib/cni/

rm -rf /var/lib/kubelet/*

rm -rf /etc/cni/

ifconfig cni0 down

ifconfig flannel.1 down

ifconfig docker0 down

ip link delete cni0

ip link delete flannel.1

systemctl start docker

 设置资源调度
使用kubeadm初始化的集群，出于安全考虑Pod不会被调度到Master Node上，也就是说Master Node不参与工作负载。这是因为当前的master节点被打上了node-role.kubernetes.io/master:NoSchedule的污点：

kubectl describe node master01 | grep Taint

Taints:             node-role.kubernetes.io/master:NoSchedule

检查join进集群的master和work节点，如果调度不对，可以通过如下方式设置：

[root@an-master01 ~]# kubectl get nodes

NAME          STATUS   ROLES    AGE     VERSION

an-master01   Ready    master   4h39m   v1.13.1

an-master02   Ready    <none>   4h32m   v1.13.1

an-master03   Ready    master   86m     v1.13.1

an-work01     Ready    <none>   85m     v1.13.1

​

查看当前状态：

kubectl describe nodes/an-master02 |grep -E '(Roles|Taints)'

Roles:              <none>

Taints:             <none>

​

设置为master节点且不调度：

kubectl label node an-master02 node-role.kubernetes.io/master=

kubectl taint nodes an-master02 node-role.kubernetes.io/master=:NoSchedule

如果想去除限制的话：

kubectl taint nodes an-master03 node-role.kubernetes.io/master-

​

work节点设置：

kubectl label node an-work01 node-role.kubernetes.io/work=

kubectl describe nodes/an-work01 |grep -E '(Roles|Taints)'

Roles:              work

Taints:             <none>

 

【前言】
 
    2019年是互联网寒冬几乎成为不争的事实，在寒冬下，往往会暴露出很多被掩盖的事实，就像下面这个案例，看完之后，深有感触。

 
作为运维工程师，坚持学习才是寒冬中的生存之道。Kubernetes的浪潮已经来了，不管我们是否愿意，生产中是否使用，Kubernetes已经不知不觉成为运维必备技能。本文介绍Kubernetes架构，作为入门的第一篇文章。    
 
Kubernetes介绍
    Kubernetes源于希腊语，意为“舵手”或“飞行员”，是用于自动部署，扩展和管理容器化应用程序的开源系统，由于K和S之间有8个字母，被简称为K8S。Kubernetes构建在Google 15年生产环境经验基础之上，可以将Kubernetes看作为Google内部的容器管理平台Borg和Omega的开源版本，当然他们之间是有一些差异的。
 
Kubernetes系统架构
    Kubernetes被设计为Master和Node两个角色，Master为控制节点，Node为计算节点或者叫工作节点，在Master节点上有一个API Server服务，对外提供标准的RestAPI，这也是Kubernetes集群的入口，意外着只要和集群进行交互必须连接到API Server上。

 
Master节点介绍
Kubernetes Master节点主要有4个组件，API Server、Scheduler、Controller、etcd。如下图所示：

• API Server：提供Kubernetes API接口，主要处理Rest操作以及更新Etcd中的对象。是所有资源增删改查的唯一入口。
• Scheduler：绑定Pod到Node上，主要做资源调度。
• Controller Manager：所有其他群集级别的功能，目前由控制器Manager执行。资源对象的自动化控制中心，Kubernetes集群有很多控制器。
• Etcd：所有持久化的状态信息存储在Etcd中，这个是Kubernetes集群的数据库。

 Node节点介绍Node节点是Kubernetes集群的工作节点，在Node节点上主要运行了Docker、Kubelet、kube-proxy三个服务（Fluentd请先忽略），如下图所示：

• Docker Engine：负责节点的容器的管理工作，最终创建出来的是一个Docker容器。
• Kubelet：安装在Node上的代理服务，和API Server进行通信，用来管理Pods以及容器、镜像、Volume等，实现对集群对节点的管理。
• Kube-proxy：安装在Node上的网络代理服务，提供网络代理以及负载均衡，实现与Service通讯。

 Kubernetes逻辑架构在上面的介绍中提到像Pod、Service这些概念，在Kubernetes的系统架构图中并没有体现出来，这些可以理解为Kubernetes逻辑架构中的组件。也就是在Master和Node上并不具体存在的一个服务或者进程，但却是Kubernetes的组件，也是我们的管理对象。主要有Pod、Service和各种控制器等。 PodPod是Kubernetes的最小管理单元，一个Pod可以包含一组容器和卷。虽然一个Pod里面可以包含一个或者多个容器，但是Pod只有一个IP地址，而且Pod重启后，IP地址会发生变化。

 Controller一个应用如果可以有一个或者多个Pod，就像你给某一个应用做集群，集群中的所有Pod是一模一样的。Kubernetes中有很多控制器可以来管理Pod，例如下图的Replication Controller可以控制Pod的副本数量，从而实现横向扩展。

 Kubernetes中有很多控制器，后面的章节我们会逐步讲到，常用的控制器如下：

• Replication Controller（新版本已经被ReplicaSet所替代）
• ReplicaSet（新版本被封装在Deployment中）
• Deployment：封装了Pod的副本管理、部署更新、回滚、扩容、缩容等功能。
• DaemonSet：保证所有的Node上有且只有一个Pod在运行。
• StatefulSet：有状态的应用，为Pod提供唯一的标识，它可以保证部署和scale的顺序。
• Job：使用Kubernetes运行单一任务。
• CronJob：使用Kubernetes运行定时任务。

Service
由于Pod的生命周期是短暂的，而且每次重启Pod的IP地址都会发生变化，而且一个Pod有多个副本，也就是说一个集群中有了多个节点，就需要考虑负载均衡的问题。Kubernetes使用Service来实现Pod的访问，而且Service有一个Cluster IP，通常也称之为VIP，是固定不变的。

 
Kubernetes网络介绍
在Kubernetes集群中存在着三种网络，分别是Node网络、Pod网络和Service网络，这几种网络之间的通信需要依靠网络插件，Kubernetes本身并没有提供，社区提供了像Flannel、Calico、Canal等，后面章节会详述。
Node网络
Node网络指的是Kubernetes Node节点本地的网络，在本实验环境中使用的是192.168.56.0/24这个网段，所有的Node和Master在该网段都可以正常通信。
Pod网络
后面创建的Pod，每一个Pod都会有一个IP地址，这个IP地址网络段被称之为Pod网络，如下图所示。

[root@linux-node1 ~]# kubectl get pod -o wide

NAME                     READY   STATUS    RESTARTS   AGE     IP         NODE                       NOMINATED NODE   READINESS GATES

nginx-54458cd494-hpn68   1/1     Running   0          9m7s    10.2.1.2   linux-node2.linuxhot.com   <none>           <none>

nginx-54458cd494-r4mfq   1/1     Running   0          7m46s   10.2.1.3   linux-node2.linuxhot.com   <none>           <none>

 
Service网络
Service是为Pod提供访问和负载均衡的网络地址段，如下图所示。

 [root@linux-node1 ~]# kubectl get service

NAME         TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE

kubernetes   ClusterIP   10.1.0.1      <none>        443/TCP        64m

nginx        NodePort    10.1.216.23   <none>        80:30893/TCP   8m3s

Kubernetes的组件和知识绝非如此，快速入门可以先了解这么多，下一章节，我们先快速的部署一个Kubernetes集群。
 
来新运维社区分享知识！
 
    欢迎来新运维社区分享你的原创文章、博文、理念或者是对运维工程师有帮助的任何知识，如要加入K8S中国交流群，请添加新运维-小助手，备注：姓名-K8S。
（无备注不予处理，请理解！）


【小助手微信】
 
- END -
 
 
加入新运维社区，开启新征程！       
 
牛人并不可怕，可怕的是牛人比我们还努力！
 

节点信息规划：
准备部署7001-7004 4个实例，但是redis集群提示最少需要3个主节点，6个节点才能完成启动，所以后面2个是后来加的。
注意：这里因为是测试环境，所以将所有实例都放在了一台机器上，生产建议主备节点不要放在一台机器上

1、环境安装

~]# cd /opt/

opt]# wget http://download.redis.io/releases/redis-4.0.11.tar.gz

opt]# tar zxf redis-4.0.11.tar.gz

opt]# cd redis-4.0.11

opt]# make test

#yum 安装tcl

opt]# yum install tcl -y

opt]# make test

#将redis的执行脚本拷贝到PATH变量所在目录或加入全局环境变量

opt]# cp -a src/redis-server src/redis-cli src/redis-sentinel src/redis-trib.rb src/redis-check-aof src/redis-check-rdb src/redis-benchmark /usr/local/bin/

2、配置redis集群文件

opt]# mkdir -p redis-cluster

opt]# mkdir -p /opt/redis-cluster/nodes-{7001,7002,7003,7004}

opt]# ln -s redis-4.0.11 redis

按需修改配置文件(以nodes-7001实例为例)

[root@shenghui-ansible opt]# egrep -v "^#|^$" redis-cluster/nodes-7001/redis.conf 

bind 192.168.56.67

protected-mode yes

port 7001

tcp-backlog 511

timeout 0

tcp-keepalive 300

daemonize yes

supervised no

pidfile redis_7001.pid

loglevel notice

logfile "/opt/redis-cluster/nodes-7001/redis_7001.log"

databases 16

always-show-logo yes

save 900 1

save 300 10

save 60 10000

stop-writes-on-bgsave-error yes

rdbcompression yes

rdbchecksum yes

dbfilename dump.rdb

dir /opt/redis-cluster/nodes-7001/

slave-serve-stale-data yes

slave-read-only yes

repl-diskless-sync no

repl-diskless-sync-delay 5

repl-disable-tcp-nodelay no

slave-priority 100

lazyfree-lazy-eviction no

lazyfree-lazy-expire no

lazyfree-lazy-server-del no

slave-lazy-flush no

appendonly yes

appendfilename "appendonly.aof"

appendfsync everysec

no-appendfsync-on-rewrite no

auto-aof-rewrite-percentage 100

auto-aof-rewrite-min-size 64mb

aof-load-truncated yes

aof-use-rdb-preamble no

lua-time-limit 5000

cluster-enabled yes

cluster-config-file nodes-7001.conf

cluster-node-timeout 5000

cluster-slave-validity-factor 10

slowlog-log-slower-than 10000

slowlog-max-len 128

latency-monitor-threshold 0

notify-keyspace-events ""

hash-max-ziplist-entries 512

hash-max-ziplist-value 64

list-max-ziplist-size -2

list-compress-depth 0

set-max-intset-entries 512

zset-max-ziplist-entries 128

zset-max-ziplist-value 64

hll-sparse-max-bytes 3000

activerehashing yes

client-output-buffer-limit normal 0 0 0

client-output-buffer-limit slave 256mb 64mb 60

client-output-buffer-limit pubsub 32mb 8mb 60

hz 10

aof-rewrite-incremental-fsync yes

3、启动redis及创建集群
依次启动各个redis实例

]# redis-server /opt/redis-cluster/nodes-7001/redis.conf

]# redis-server /opt/redis-cluster/nodes-7002/redis.conf

]# redis-server /opt/redis-cluster/nodes-7003/redis.conf

]# redis-server /opt/redis-cluster/nodes-7004/redis.conf

4、创建redis集群
创建redis集群使用redis-trib.rb命令，该命令是基于ruby的脚本，需要安装ruby，ruby-gem以及gem-redis
#如果有老版本，卸载ruby2.0.0，安装ruby2.2.2以上版本

[root@elk01 ~]# ruby -v  #centos7 忽略

ruby 2.0.0p648 (2015-12-16) [x86_64-linux]

[root@elk01 ~]# yum erase ruby

~]# wget https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.3.tar.gz

~]# tar zxf ruby-2.5.3.tar.gz

~]# cd ruby-2.5.3/

ruby-2.5.3]# ./configure

ruby-2.5.3]# make

安装ruby-redis.gem
推荐：如果默认国外的gem源连不上或者很慢，可以试试国内源
添加国内源命令：gem source -a https://gems.ruby-china.com
删除国外源并添加国内源：gem sources --add https://gems.ruby-china.com/ --remove https://rubygems.com/
#检测gem源，注意RubyGems源尽量用新版本，官方建议2.6.X，但是我用2.5.2也没什么问题

[root@shenghui-ansible ~]# gem source -l

*** CURRENT SOURCES ***



https://gems.ruby-china.com

redis-cluster]# gem install redis -v 3.3.5    #注：不要使用4.x版本，不然后期增加实例，迁移哈希槽会失败

创建集群报错：

root@elk01 redis-cluster]# redis-trib.rb create --replicas 1 192.168.56.67:7001 192.168.56.67:7002 192.168.56.67:7003 192.168.56.67:7004

>>> Creating cluster

*** ERROR: Invalid configuration for cluster creation. #错误表示redis集群至少要3个主，6个节点

*** Redis Cluster requires at least 3 master nodes.

*** This is not possible with 4 nodes and 1 replicas per node.

*** At least 6 nodes are required.

#新增两个节点

redis-cluster]# mkdir -p nodes-{7005,7006}

#拷贝并修改下redis配置ip

redis-cluster]# cp nodes-7001/redis.conf nodes-7005/

redis-cluster]# cp nodes-7001/redis.conf nodes-7006/

启动redis

redis-server /opt/redis-cluster/nodes-7005/redis.conf

redis-server /opt/redis-cluster/nodes-7006/redis.conf

[root@shenghui-ansible ~]# ps -ef|grep redis

root      26651      1  0 Nov13 ?        00:01:10 redis-server 127.0.0.1:7002 [cluster]

root      26656      1  0 Nov13 ?        00:01:10 redis-server 127.0.0.1:7003 [cluster]

root      26661      1  0 Nov13 ?        00:01:09 redis-server 127.0.0.1:7004 [cluster]

root      26666      1  0 Nov13 ?        00:01:10 redis-server 127.0.0.1:7005 [cluster]

root      26671      1  0 Nov13 ?        00:01:09 redis-server 127.0.0.1:7006 [cluster]

root      26725      1  0 Nov13 ?        00:01:11 redis-server 127.0.0.1:7001 [cluster]

#创建集群成功

redis-cluster]# redis-trib.rb create --replicas 1 192.168.56.67:7001 192.168.56.67:7002 192.168.56.67:7003 192.168.56.67:7004 192.168.56.67:7005 192.168.56.67:7006

>>> Creating cluster

>>> Performing hash slots allocation on 6 nodes...

Using 3 masters:

192.168.56.67:7001

192.168.56.67:7002

192.168.56.67:7003

Adding replica 192.168.56.67:7004 to 192.168.56.67:7001

Adding replica 192.168.56.67:7005 to 192.168.56.67:7002

Adding replica 1192.168.56.67:7006 to 192.168.56.67:7003

M: 23df12c2bafde34f5bdd53d3463ad20b8ab507d2 192.168.56.67:7001

集群测试：

[root@shenghui-ansible ~]# redis-cli -c -p 7001 #登陆操作集群，-c参数是必须的

127.0.0.1:7001> cluster info

cluster_state:ok

cluster_slots_assigned:16384

cluster_slots_ok:16384

cluster_slots_pfail:0

cluster_slots_fail:0

cluster_known_nodes:6

cluster_size:3

cluster_current_epoch:7

cluster_my_epoch:7

cluster_stats_messages_ping_sent:84881

...

127.0.0.1:7001> cluster nodes

21da5db87c968a926ac98db20c6b3e5db98e86b4 192.168.56.67:7001@17001 myself,slave 64f7850f021d1150b41fc654f247e075f8573813 0 1542181496000 1 connected

bbba5557051520f7d825819415a806b8716f811c 127.0.0.1:7002@17002 master - 0 1542181497150 2 connected 5461-10922

f707863e9846cf9e7c68fd7cdae5b72aa4f6839b 127.0.0.1:7004@17004 slave 66ebc6a414a533a9a2ed27fbcdbea88b9d8ed4db 0 1542181498161 4 connected

ecdf34327e274a8294f7225ddbb5d3f4cd0b7bde 127.0.0.1:7006@17006 slave bbba5557051520f7d825819415a806b8716f811c 0 1542181497000 6 connected

64f7850f021d1150b41fc654f247e075f8573813 127.0.0.1:7005@17005 master - 0 1542181495000 7 connected 0-5460

66ebc6a414a533a9a2ed27fbcdbea88b9d8ed4db 127.0.0.1:7003@17003 master - 0 1542181495132 3 connected 10923-16383

127.0.0.1:7001> set liubai 'papa'

-> Redirected to slot [11252] located at 127.0.0.1:7003

OK

127.0.0.1:7003> get liubai

"papa"

nodes-7001宕机查看数据(redis集群去中心化，连接哪一台都可以)：

~]# kill -9 26725  #生长不建议使用kill，登陆redis-cli 使用shutdown关闭redis

 [root@shenghui-ansible ~]# redis-cli -c -p 7002

127.0.0.1:7002> get liubai

-> Redirected to slot [11252] located at 127.0.0.1:7003  #数据在nodes3，从自动切换选举为主

"papa"

127.0.0.1:7003> cluster nodes

bbba5557051520f7d825819415a806b8716f811c 127.0.0.1:7002@17002 master - 0 1542181782880 2 connected 5461-10922

21da5db87c968a926ac98db20c6b3e5db98e86b4 127.0.0.1:7001@17001 slave,fail 64f7850f021d1150b41fc654f247e075f8573813 1542181666613 1542181664000 7 disconnected

64f7850f021d1150b41fc654f247e075f8573813 127.0.0.1:7005@17005 master - 0 1542181780860 7 connected 0-5460

66ebc6a414a533a9a2ed27fbcdbea88b9d8ed4db 127.0.0.1:7003@17003 myself,master - 0 1542181781000 3 connected 10923-16383

f707863e9846cf9e7c68fd7cdae5b72aa4f6839b 127.0.0.1:7004@17004 slave 66ebc6a414a533a9a2ed27fbcdbea88b9d8ed4db 0 1542181781869 4 connected

ecdf34327e274a8294f7225ddbb5d3f4cd0b7bde 127.0.0.1:7006@17006 slave bbba5557051520f7d825819415a806b8716f811c 0 1542181780000 6 connected

127.0.0.1:7003> get liubai

"papa"

 
2014年写的Zabbix监控插件，主要监控TCP的11种状态、Nginx状态、Redis和Memcached状态。
 
监控模板请查看附件。直接导入到Zabbix中即可。
 
Nginx监控状态配置默认使用127.0.0.1获取。
 
Nginx监控配置：
 
1.为Nginx增加状态配置文件。

[root@linux-node2 ~]# yum install -y nginx

[root@linux-node2 ~]# vim /etc/nginx/conf.d/nginx-status.conf

server {

       server_name 127.0.0.1;

       location /nginx_status {

                stub_status on;

                access_log off;

                allow 127.0.0.1;

                deny all;

                }

}

2.测试Nginx配置并启动

[root@linux-node2 ~]# nginx -t

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok

nginx: configuration file /etc/nginx/nginx.conf test is successful

[root@linux-node2 ~]# systemctl start nginx

3.测试Nginx状态接口

[root@linux-node2 ~]# curl http://127.0.0.1/nginx_status

Active connections: 1 

server accepts handled requests

 7 7 7 

Reading: 0 Writing: 1 Waiting: 0

 
  

#!/bin/bash

############################################################

# $Name:         zabbix_linux_plugins.sh

# $Version:      v1.0

# $Function:     zabbix plugins

# $Author:       Jason Zhao

# $organization: www.unixhot.com

# $Create Date:  2014-08-10

# $Description:  Monitor Linux Service Status

############################################################

tcp_status_fun(){

	TCP_STAT=$1

	#netstat -n | awk '/^tcp/ {  state[$NF]} END {for(key in state) print key,state[key]}' > /tmp/netstat.tmp

	ss -ant | awk 'NR>1 {  s[$1]} END {for(k in s) print k,s[k]}' > /tmp/netstat.tmp

	TCP_STAT_VALUE=$(grep "$TCP_STAT" /tmp/netstat.tmp | cut -d ' ' -f2)

	if [ -z $TCP_STAT_VALUE ];then

		TCP_STAT_VALUE=0

	fi

	echo $TCP_STAT_VALUE

}



nginx_status_fun(){

	NGINX_PORT=$1

	NGINX_COMMAND=$2

	nginx_active(){

        /usr/bin/curl "http://127.0.0.1:"$NGINX_PORT"/nginx_status/" 2>/dev/null| grep 'Active' | awk '{print $NF}'

        }

	nginx_reading(){

        /usr/bin/curl "http://127.0.0.1:"$NGINX_PORT"/nginx_status/" 2>/dev/null| grep 'Reading' | awk '{print $2}'

       }

	nginx_writing(){

        /usr/bin/curl "http://127.0.0.1:"$NGINX_PORT"/nginx_status/" 2>/dev/null| grep 'Writing' | awk '{print $4}'

       }

	nginx_waiting(){

        /usr/bin/curl "http://127.0.0.1:"$NGINX_PORT"/nginx_status/" 2>/dev/null| grep 'Waiting' | awk '{print $6}'

       }

	nginx_accepts(){

        /usr/bin/curl "http://127.0.0.1:"$NGINX_PORT"/nginx_status/" 2>/dev/null| awk NR==3 | awk '{print $1}'

       }

	nginx_handled(){

        /usr/bin/curl "http://127.0.0.1:"$NGINX_PORT"/nginx_status/" 2>/dev/null| awk NR==3 | awk '{print $2}'

       }

	nginx_requests(){

        /usr/bin/curl "http://127.0.0.1:"$NGINX_PORT"/nginx_status/" 2>/dev/null| awk NR==3 | awk '{print $3}'

       }

  	case $NGINX_COMMAND in

		active)

			nginx_active;

			;;

		reading)

			nginx_reading;

			;;

		writing)

			nginx_writing;

			;;

		waiting)

			nginx_waiting;

			;;

		accepts)

			nginx_accepts;

			;;

		handled)

			nginx_handled;

			;;

		requests)

			nginx_requests;

		esac 

}



memcached_status_fun(){

	M_PORT=$1

	M_COMMAND=$2

	echo -e "stats\nquit" | nc 127.0.0.1 "$M_PORT" | grep "STAT $M_COMMAND " | awk '{print $3}'

}



redis_status_fun(){

	R_PORT=$1

	R_COMMAND=$2

	(echo -en "INFO \r\n";sleep 1;) | nc 127.0.0.1 "$R_PORT" > /tmp/redis_"$R_PORT".tmp

	REDIS_STAT_VALUE=$(grep ""$R_COMMAND":" /tmp/redis_"$R_PORT".tmp | cut -d ':' -f2)

 	echo $REDIS_STAT_VALUE	

}



main(){

	case $1 in

		tcp_status)

			tcp_status_fun $2;

			;;

		nginx_status)

			nginx_status_fun $2 $3;

			;;

		memcached_status)

			memcached_status_fun $2 $3;

			;;

		redis_status)

			redis_status_fun $2 $3;

			;;

		*)

			echo $"Usage: $0 {tcp_status key|memcached_status key|redis_status key|nginx_status key}"

	esac

}



main $1 $2 $3

 
使用方法：

[root@linux-node2 ~]# ./zabbix_linux_plugin.sh 

Usage: ./zabbix_linux_plugin.sh {tcp_status key|memcached_status key|redis_status key|nginx_status key}

 
获取TCP监控状态

[root@linux-node2 ~]# ./zabbix_linux_plugin.sh tcp_status LISTEN

14

 

 如果需要使用Zabbix Java Gateway监控JMX，需要先打开JMX监控接口。
 
1.Tomcat部署可以在http://tomcat.apache.org/官网上下载对应的版本。这里在linux-node2这个实验节点上，使用Tomcat8做实验。 
 
安装JDK1.8和Tomcat-8.5.20 

[root@linux-node2 ~]# yum install -y java-1.8.0

[root@linux-node2 ~]# cd /usr/local/src

# wget http://mirrors.hust.edu.cn/apache/tomcat/tomcat-8/v8.5.20/bin/apache-tomcat-8.5.20.tar.gz

[root@linux-node2 src]# tar zxf apache-tomcat-8.5.20.tar.gz 

[root@linux-node2 src]# mv apache-tomcat-8.5.20 /usr/local/

[root@linux-node2 src]# ln -s /usr/local/apache-tomcat-8.5.20/ /usr/local/tomcat

2.Tomcat开启JMX监控
JMX监控设置有三种类型：

• 无验证的JMX监控
• 用户名密码认证
• SSL加密

 

[root@linux-node2 ~]# vim /usr/local/tomcat/bin/catalina.sh

CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=8888 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=192.168.56.12"

参数行中的com.sun.management.jmxremote.port参数是tomcat JMX监听的端口，可以随意配置，但是不可已经被占用；java.rmi.server.hostname参数的IP地址为远程Linux服务器的IP地址。

 
3.启动Tomcat

[root@linux-node2 ~]# /usr/local/tomcat/bin/startup.sh 

Using CATALINA_BASE:   /usr/local/tomcat

Using CATALINA_HOME:   /usr/local/tomcat

Using CATALINA_TMPDIR: /usr/local/tomcat/temp

Using JRE_HOME:        /usr

Using CLASSPATH:       /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar

Tomcat started.

[root@linux-node2 ~]# netstat -ntlp | grep 8888

tcp6       0      0 :::8888                 :::*                    LISTEN      6154/java