WF's Blog 2022-10-31T16:37:22.000Z http://linuxwf.com/ Wu Fei Hexo 1.多节点安装ks+k8s http://linuxwf.com/2022/11/01/1-%E5%A4%9A%E8%8A%82%E7%82%B9%E5%AE%89%E8%A3%85ks-k8s/ 2022-10-31T16:36:00.000Z 2022-10-31T16:37:22.000Z

1.多节点安装ks+k8s

概念

多节点集群由至少一个主节点和一个工作节点组成。您可以使用任何节点作为任务机来执行安装任务，也可以在安装之前或之后根据需要新增节点（例如，为了实现高可用性）。

  • Control plane node：主节点，通常托管控制平面，控制和管理整个系统。
  • Worker node：工作节点，运行部署在工作节点上的实际应用程序。

步骤 1：准备 Linux 主机

硬件推荐配置

操作系统最低配置
Ubuntu 16.04, 18.042 核 CPU，4 GB 内存，40 GB 磁盘空间
Debian Buster, Stretch2 核 CPU，4 GB 内存，40 GB 磁盘空间
CentOS 7.x2 核 CPU，4 GB 内存，40 GB 磁盘空间
Red Hat Enterprise Linux 72 核 CPU，4 GB 内存，40 GB 磁盘空间Debian Buster, Stretch
SUSE Linux Enterprise Server 15/openSUSE Leap 15.22 核 CPU，4 GB 内存，40 GB 磁盘空间Debian Buster, Stretch

依赖项要求

KubeKey 可以将 Kubernetes 和 KubeSphere 一同安装。针对不同的 Kubernetes 版本，需要安装的依赖项可能有所不同。您可以参考以下列表，查看是否需要提前在节点上安装相关的依赖项。

依赖项Kubernetes 版本 ≥ 1.18Kubernetes 版本 < 1.18
socat必须可选但建议
conntrack必须可选但建议
ebtables可选但建议可选但建议
ipset可选但建议可选但建议

项目准备

主机 IP主机名角色
10.0.0.200control planecontrol plane, etcd
10.0.0.201node01worker
10.0.0.202node02worker+harbor

节点要求

  • 所有节点必须都能通过 SSH 访问。
  • 所有节点时间同步。
  • 所有节点都应使用 sudo/curl/openssl/tar。

配置所有节点ssh互相访问：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1.三台机器分别执行以下命令
ssh-keygen

2.查看公钥
cat id_rsa.pub

3.把公钥加入到authorized_keys文件
[root@master ~/.ssh]# cat authorized_keys 
ssh-rsa xxx root@master
ssh-rsa xxx root@node01
ssh-rsa xxx root@node02

4.验证
ssh 10.0.0.201 hostname
ssh 10.0.0.202 hostname

步骤 2：下载 KubeKey

提前准备工作：

1
2
3
4
5
6
7
8
9
10
11
#关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

#关闭 selinux
sentenforce 0
sed -i 's/enforcing/disabled/' /etc/selinux/config

#关闭 swap
swapoff -a  #临时
sed -ri 's/.*swap.*/#&/' /etc/fstab  #永久

下载 KubeKey：

1
2
3
4
5
6
7
8
9
10
11
12
#创建kk目录
mkdir /data && cd /data

#如果您能正常访问 GitHub/Googleapis
curl -sfL https://get-kk.kubesphere.io | VERSION=v2.2.1 sh -

#如果您访问 GitHub/Googleapis 受限
export KKZONE=cn
curl -sfL https://get-kk.kubesphere.io | VERSION=v2.2.1 sh -

#为 kk 添加可执行权限：
chmod +x kk

步骤 3：创建集群

对于多节点安装，您需要通过指定配置文件来创建集群。

1. 创建示例配置文件

命令如下：

1
./kk create config --with-kubernetes v1.22.10 --with-kubesphere v3.3.0

2. 编辑配置文件

如果您不更改名称，那么将创建默认文件 config-sample.yaml。编辑文件，以下是多节点集群（具有一个主节点）配置文件的示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
apiVersion: kubekey.kubesphere.io/v1alpha2
kind: Cluster
metadata:
  name: sample
spec:
  hosts:
  - {name: master, address: 10.0.0.200, internalAddress: 10.0.0.200, privateKeyPath: "~/.ssh/id_rsa"}
  - {name: node01, address: 10.0.0.201, internalAddress: 10.0.0.201, privateKeyPath: "~/.ssh/id_rsa"}
  - {name: node02, address: 10.0.0.202, internalAddress: 10.0.0.202, privateKeyPath: "~/.ssh/id_rsa"}
  roleGroups:
    etcd:
    - master
    control-plane:
    - master
    worker:
    - node01
    - node02
    registry:
    - node02

network:
    plugin: calico
    kubePodsCIDR: 10.233.64.0/18
    kubeServiceCIDR: 10.233.0.0/18
    ## multus support. https://github.com/k8snetworkplumbingwg/multus-cni
    multusCNI:
      enabled: false
  registry:
    type: harbor
    privateRegistry: ""
    namespaceOverride: ""
    registryMirrors: []
    insecureRegistries: []
  addons: []
  
  alerting:
    enabled: true    #告警系统
  auditing:
    enabled: true    #审计日志
  devops:
    enabled: true    #devops
  openpitrix:
    store:
      enabled: true  #应用商店

备注：
roleGroups

  • etcd：etcd 节点名称
  • control-plane：主节点名称
  • worker：工作节点名称

使用 SSH 密钥的无密码登录示例：

1
2
hosts:
  - {name: master, address: 10.0.0.200, internalAddress: 10.0.0.200, privateKeyPath: "~/.ssh/id_rsa"}

3. 使用配置文件创建集群

备注：每个节点安装依赖项

1
yum install -y  socat conntrack ebtables ipset

安装集群

1
./kk create cluster -f config-sample.yaml

4. 验证安装

执行以下命令查看集群状态：

1
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l 'app in (ks-install, ks-installer)' -o jsonpath='{.items[0].metadata.name}') -f

报错：提示 -bash: kubectl: command not found ，这里配置环境变量使之生效

1
2
3
4
[root@master ~]# whereis is kubectl
[root@master ~]# vim /etc/profile              最后一行加入
export PATH="/usr/local/bin/:$PATH"
[root@master ~]# source /etc/profile

安装完成后，您会看到如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#####################################################
###              Welcome to KubeSphere!           ###
#####################################################

Console: http://10.0.0.200:30880
Account: admin
Password: P@88w0rd

NOTES：
  1. After you log into the console, please check the
     monitoring status of service components in
     the "Cluster Management". If any service is not
     ready, please wait patiently until all components
     are up and running.
  2. Please change the default password after login.

#####################################################
https://kubesphere.io             20xx-xx-xx xx:xx:xx
#####################################################

现在，您可以通过 <NodeIP:30880 使用默认帐户和密码 (admin/P@88w0rd) 访问 KubeSphere 的 Web 控制台。

image

步骤 4：启用 kubectl 自动补全

KubeKey 不会启用 kubectl 自动补全功能，请参见以下内容并将其打开：

备注：

请确保已安装 bash-autocompletion 并可以正常工作。

1
2
3
4
5
6
7
8
# Install bash-completion
apt-get install bash-completion

# Source the completion script in your ~/.bashrc file
echo 'source <(kubectl completion bash)' >>~/.bashrc

# Add the completion script to the /etc/bash_completion.d directory
kubectl completion bash >/etc/bash_completion.d/kubectl

步骤 5：安装内网穿透工具 ZeroTier

1.注册账号

访问：https://www.zerotier.com/ 注册账号；

2.创建虚拟网络

  1. 点击“Create A Network”创建一个虚拟网络：
  2. 记住Network ID，后边会用到；
    Name随便写；
    Access Control选择：PRIVATE；

3.配置网段

  1. IPV4 Auto-Assign 选择“Easy”，然后从下发的网段选择一个即可；
  2. 这里选择的是10.242..，上方的Managed Routes会自动修改为：10.242.0.0/16 (LAN);
  3. 表示：10.242..的虚拟网段，由ZeroTier进行路由转发；

  1. 剩下部分保留默认配置即可；接下来配置客户端。

4.客户端配置

  1. 下载并安装ZeroTier客户端：https://www.zerotier.com/download/

  2. 按照官网提示，安装ZeroTier客户端即可；

    1
    curl -s https://install.zerotier.com | sudo bash

    若需要，可以通过以下命令获取设备的address地址：

    1
    cat /var/lib/zerotier-one/identity.public |cut -d : -f 1

  3. 配置客户端，加入虚拟网络：

    1
    zerotier-cli join <Network ID>

    MacOS和Windows系统，打开客户端，粘贴Network ID，然后点击“Join Network”：

  4. 回到管理UI，找到刚刚申请加入的设备，点击左侧的“Auth?”复选框，给新加入的设备授权：

    “Name”随便写；
    “Managed IPs”，输入“10.242.0.0”至“10.242.255.255”之间的任意IP，网段对应上一步创建的网段即可；
    点击“Managed IPs”左侧的“+”，生成虚拟IP；

  1. 客户端配置完成；可以回到客户端，查看是否正常：
  2. 将多个设备加入虚拟网络；如果是云服务器，记得开放相应的端口；
  3. 多个设备之间，可以使用虚拟IP互联；

5.moon节点配置

官方的节点，速度比较慢；可以通过自建中继节点（moon）的方式，提高连接速度；
自建的moon节点服务器必须有外网IP，才有意义；

  1. 在Linux的服务器上，配置moon服务器：
1
2
3
cd /var/lib/zerotier-one
#生成moon
zerotier-idtool initmoon identity.public >>moon.json
  1. 修改 moon.json文件的id地址、stableEndpoints值
1
2
"id": "12345678",
"stableEndpoints": ["1.2.3.4/9993"]
  1. 启动moon服务器：
1
2
3
4
5
6
7
#生成签名文件
zerotier-idtool genmoon moon.json                #会生成类似：000000xxxxxxxx.moon的文件

#将 moon 节点加入网络
mkdir moons.d
cp 000000xxxxxxxx.moon /moons.d/
systemctl restart zerotier-one.service
  1. 其他客户端连接moon服务器：
1
2
3
4
5
#Linux
#连接moon节点：
#注意这里的12345678为上边moon.json里的id
#orbit后边跟两个id
zerotier-cli orbit 12345678 12345678
  1. 如果是Windows系统：
1
C:\Program Files (x86)\ZeroTier\One> .\zerotier-cli.bat orbit 12345678 12345678
  1. 查看节点连接信息：
1
2
3
zerotier-cli listpeers
#结果中可以看到新加入的moon节点；
#如果没有，可以稍等一会；
  1. 卸载Zerotier-one
1
2
3
4
5
1.通过dpkg删除zerotier-one服务
dpkg -P zerotier-one

2.删除zerotier-one文件夹，该文件夹存储了address地址，删除后再次安装会获得新的address地址
rm -rf /var/lib/zerotier-one/
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla Nginx优化之高并发配置 http://linuxwf.com/2022/11/01/Nginx%E4%BC%98%E5%8C%96%E4%B9%8B%E9%AB%98%E5%B9%B6%E5%8F%91%E9%85%8D%E7%BD%AE/ 2022-10-31T16:23:00.000Z 2022-10-31T16:23:38.000Z

Nginx优化之高并发配置

1.高并发简介

高并发（High Concurrency）通常是指通过设计保证系统能够同时并行处理很多请求。通俗来讲，高并发是指在同一个时间点，有很多用户同时的访问同一 API 接口或者 Url 地址。它经常会发生在有大活跃用户量，用户高聚集的业务场景中。

2.优化思路

2.1 系统层面优化

1
2
3
4
5
6
7
8
9
10
11
12
#调整同时打开文件数量
ulimit -n 65536

#TCP最大连接数(somaxconn)
echo 10000 > /proc/sys/net/core/somaxconn

#TCP连接立即回收、回用(recycle、reuse)
echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse
echo 1 > /proc/sys/net/ipv4/tcp_tw_recycle

#不做TCP洪水抵御
echo 0 > /proc/sys/net/ipv4/tcp_syncookies

2.2 Linux内核参数优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#优化内核参数
vim /etc/sysctl.conf

net.core.somaxconn = 262144
net.core.rmem_default = 262144
net.core.wmem_default = 262144
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 4096 16777216
net.ipv4.tcp_wmem = 4096 4096 16777216
net.ipv4.tcp_mem = 786432 2097152 3145728
net.ipv4.tcp_max_syn_backlog = 16384
net.core.netdev_max_backlog = 20000
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_max_syn_backlog = 16384
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_max_orphans = 131072
net.ipv4.tcp_syncookies = 0

#生效
sysctl -p

2.3 Nginx配置文件优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
vim /etc/nginx/nginx.conf

worker_processes auto; #工作进程数
worker_rlimit_nofile 65535;#工作进程最大打开文件数
events {
    use epoll;#使用epoll事件驱动模型
    worker_connections 65535;#工作进程最大连接数
    multi_accept on;#设置工作进程同时接收多个网络连接
}

http {
    sendfile            on;#开启高效文件传输模式
    send_timeout       10s;#设置服务器和客户端连接超时时间
    client_header_buffer_size 4k;#客户端请求头部的缓冲区大小
    tcp_nopush          on;#将响应头和正文的开始部分一起发送，而不一个接一个的发送。
    tcp_nodelay         on;#不要缓存数据
    keepalive_timeout   0;#服务器和客户端保持活动的时间是65s，之后断开，高并发时可以设置为0    
}

2.4 扩展服务器的CPU和内存

这个就不在这里说了，这个大家都懂的操作，再说就没意义了。无非就是联系厂商增加CPU和内存，或者自己买CPU和内存，是云上的就扩展CPU和内存就可以了。

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 7.Pipeline分布式构建 http://linuxwf.com/2020/04/15/7-Pipeline%E5%88%86%E5%B8%83%E5%BC%8F%E6%9E%84%E5%BB%BA/ 2020-04-15T11:58:00.000Z 2020-04-15T11:59:33.000Z

pipeline分布式构建

第1章 Jenkins Pipeline项目

CI/CD持续集成/持续部署

持续集成(Continuous integration)是一种软件开发实践，即团队开发成员经常集成它们的工作，通过每个成员每天至少集成一次，也就意味着每天可能会发生多次集成。每次集成都通过自动化的构建（包括编译，发布，自动化测试）来验证，从而尽早地发现集成错误。比如（你家装修厨房，其中一项是铺地砖，边角地砖要切割大小。如果一次全切割完再铺上去，发现尺寸有误的话浪费和返工时间就大了，不如切一块铺一块。这就是持续集成。）

持续部署（continuous deployment）是通过自动化的构建、测试和部署循环来快速交付高质量的产品。某种程度上代表了一个开发团队工程化的程度，毕竟快速运转的互联网公司人力成本会高于机器，投资机器优化开发流程化

相对也提高了人的效率。比如（装修厨房有很多部分，每个部分都有检测手段，如地砖铺完了要测试漏水与否，线路铺完了要通电测试电路通顺，水管装好了也要测试冷水热水。如果全部装完了再测，出现问题可能会互相影响，比如电路不行可能要把地砖给挖开……。那么每完成一部分就测试，这是持续部署。）

持续交付 Continuous Delivery:频繁地将软件的新版本，交付给质量团队或者用户，以供评审尽早发现生产环境

中存在的问题；如果评审通过，代码就进入生产阶段

比如（全部装修完了，你去验收，发现地砖颜色不合意，水池太小，灶台位置不对，返工吗？所以不如没完成一部分，你就去用一下试用验收，这就是持续交付。）

敏捷思想中提出的这三个观点，还强调一件事：通过技术手段自动化这三个工作。加快交付速度。

什么是pipeline

Jenkins 2.0的精髓是Pipeline as Code，是帮助Jenkins实现CI到CD转变的重要角色。什么是Pipeline，简单

来说，就是一套运行于Jenkins上的工作流框架，将原本独立运行于单个或者多个节点的任务连接起来，实现单个

任务难以完成的复杂发布流程。Pipeline的实现方式是一套Groovy DSL，任何发布流程都可以表述为一段Groovy

脚本，并且Jenkins支持从代码库直接读取脚本，从而实现了Pipeline as Code的理念。

Pipeline 概念

Pipeline 是一个用户定义的 CD 流水线模式。Pipeline 代码定义了通常包含构建、测试和发布步骤的完整的构

建过程。

Node

node 是一个机器，它是 Jenkins 环境的一部分，并且能够执行 Pipeline。同时，node 代码块也是脚本式

Pipeline 语法的关键特性。

Stage

Stage 块定义了在整个 Pipeline 中执行的概念上不同的任务子集（例如“构建”，“测试”和“部署”阶段），

许多插件使用它来可视化或呈现 Jenkins 管道状态/进度。

Step

一项任务。从根本上讲，一个步骤告诉 Jenkins 在特定时间点（或过程中的“步骤”）要做什么。例如，使用

sh step：sh ‘make’ 可以执行 make 这个 shell 命令。

jenkins file

脚本式语法格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
pipeline{
    agent any
    stages{
        stage("get code"){
           steps{
               echo "get code from scm"
           }
        }
        stage("package"){
            steps{
                echo "packge code"
            }
        }
        stage("deploy"){
            steps{
                echo "deploy packge to node1"
            }
        }
    }
}

创建一个pipeline测试

使用测试pipeline脚本测试

创建一个jenkinsfile项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
pipeline{
    agent any
    stages{
        stage("get code"){
           steps{
                echo "get code"
           }
        }
        stage("unit test"){
           steps{
                sh '/usr/local/sonar-scanner/bin/sonar-scanner -Dsonar.projectKey=html  -Dsonar.projectName=${JOB_NAME} -Dsonar.sources=.'
           }
        }
        stage("package"){
            steps{
                sh 'tar zcf /opt/web-${BUILD_ID}.tar.gz ./* --exclude=./git --exclude=jenkinsfile'
            }
        }
        stage("deploy"){
            steps{
                sh 'ssh 10.0.1.7 "cd /code/www/ && mkdir web-${BUILD_ID}"'
                sh 'scp /opt/web-${BUILD_ID}.tar.gz 10.0.1.7:/code/www/web-${BUILD_ID}'
                sh 'ssh 10.0.1.7 "cd /code/www/web-${BUILD_ID} && tar xf web-${BUILD_ID}.tar.gz && rm -rf web-${BUILD_ID}.tar.gz"'
                sh 'ssh 10.0.1.7 "cd /code/www/ && rm -rf html && ln -s web-${BUILD_ID} /code/www/html"'
            }
        }
    }
}

配置pipeline流水线

在gitlab上创建Jenkinsfile，并写入脚本

返回jenkins重新构建

使用Blue Ocean查看

第2章 分布式构建

分布式构建

如果项目需要定期集成，同时每次集成都需要较长时间。如果都运行在master服务器上，会消耗过多资源，导致其他项目搁置无法集成，这时就需要在建立多台设备，并配置作为slave机器来为master提供负载服务。

1.环境准备

找一台或者目前已有的服务器配置为slave端 #当前使用soar服务器作为slave测试

在sonar上安装java jdk git 和soanr 客户端

#如已安装则略过

1
yum -y install java git

scp jenkins上已配置好的客户端到此服务器 sonar和maven

jenkins服务器操作 注意带版本号做软链接

1
2
3
4
5
6
7
scp -r /usr/local/sonar-scanner-4.0.0.1744-linux 10.0.1.203:/usr/local/
scp -r /usr/local/apache-maven-3.3.9 10.0.1.203:/usr/local/
ssh 10.0.1.203 "mkdir /server/scripts -p"
scp /server/scripts/* 10.0.1.203:/server/scripts/

#做免秘钥认证拷贝jenkins公钥到slave，私钥配置到jenkins
cd && ssh-copy-id -i .ssh/id_rsa.pub 10.0.1.203

返回sonar上创建软链接

1
2
ln -s sonar-scanner-4.0.0.1744-linux sonar-scanner
ln -s apache-maven-3.3.9 maven

slave服务器上做连接web的免秘钥认证

1
2
ssh-keygen -t rsa
ssh-copy-id -i .ssh/id_rsa.pub 10.0.1.7

2.新建节点

点击系统管理->节点管理->新建节点

配置工具默认目录

配置成功后的状态

显示已经同步成功

3.构建多个项目测试

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 6.nexus参数化构建 http://linuxwf.com/2020/04/15/6-nexus%E5%8F%82%E6%95%B0%E5%8C%96%E6%9E%84%E5%BB%BA/ 2020-04-15T11:41:00.000Z 2020-04-15T11:42:30.000Z

nexus参数化构建

第1章 nexus私有仓库

部署私服 nexus 下载https://www.sonatype.com/download‐oss‐sonatype

配置仓库两个选项

  1. 项目下的pom.xml配置、只生效当前的项目

  2. 在maven配置全局所有项目生效

上传JDK和nexus安装包

1
2
3
4
5
6
7
8
rpm -ivh jdk-8u181-linux-x64.rpm
tar xf nexus-3.13.0-01-unix.tar.gz -C /usr/local/
ln -s nexus-3.13.0-01 nexus
cd /usr/local/nexus/bin/
./nexus start
./nexus status
netstat -lntup
tcp        0      0 0.0.0.0:8081            0.0.0.0:*               LISTEN      3286/java

访问10.0.1.202:8081测试

登录更改默认源为阿里源，登录用户admin密码admin123

阿里源地址：http://maven.aliyun.com/nexus/content/groups/public

修改maven配置文件

上传新文件，更改三处IP地址，指向nexus私服

1
2
cd /usr/local/maven/conf/
mv settings.xml settings.xml.bak

具体配置方法,查看附件nexus.txt文件：

配置完成后去jenkins使用mvn测试

1
2
mvn clean
mvn package

返回nexus http://10.0.1.202:8081/查看，已经搭建完成

第2章 参数化构建

参数化构建，通过tag传递参数达到发布和代码回滚的操作

修改项目配置

注: 接下来安装插件、在可选插件中搜索Git Parameter 直接安装即可，已安装则忽略次步骤

进入到项目把前面的参数化去掉重新选择使用git parameter

修改参数化构建

修改test-job的 Branches to build 为${git_version}

返回test-job查看

立即构建变成Build with Parameters

gitlab下创建标签并上传远程仓库

1
2
3
4
5
6
7
8
9
10
1.查看标签     git tag
2.编辑网页内容，并提交，打上标签   
/root/dzp && vim index.html
git commit -am "vx.0"
git tag -a vx.0 -m "vx.0"

3.上传到远程仓库
git push -u origin vx.0

#分别创建标签v1.0 v2.0 v3.0 v4.0

使用devploy发布版本和使用rollback回滚版本

devploy发布1.0-4.0版本

rollback进行版本回滚，从v4.0返回v3.0

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 5.jenkins+sonar http://linuxwf.com/2020/04/15/5-jenkins-sonar/ 2020-04-15T10:50:00.000Z 2020-04-15T10:51:31.000Z

安装jenkins

安装准备

装备两台服务器 关闭selinux和防火墙

jenkins 10.0.1.201 内存2G 50G+硬盘

sonar 10.0.1.203 内存4G 50G+硬盘

安装JDK运行环境和jenkins服务

上传JDK和jenkins rpm安装包，使用rpm ‐ivh进行安装,安装完JDK运维java测试是否安装成功

1
2
3
rpm -ivh jdk-8u181-linux-x64.rpm
rpm -ivh jenkins-2.176.1-1.1.noarch.rpm
rpm -ql jenkins  --->查看安装内容

配置jenkins

1
2
3
4
5
6
#启动用户修改为root
vim /etc/sysconfig/jenkins
JENKINS_USER="root"

systemctl start jenkins
systemctl enable jenkins

访问页面进行配置

http://10.0.0.201:8080

查看管理员密码

1
2
[root@jenkins2 ~]# cat /var/lib/jenkins/secrets/initialAdminPassword
9429ed982c10419e89ff06443eb3ac09

选择不安装插件，直接X掉，然后修改admin密码为123

插件安装

更改下载地址

1
https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

（跳过安装插件，直接上传插件到目录）和修改登录密码

  1. 自动安装可选插件

  2. 手动下载插件上传安装

  3. 插件放入插件目录

1
2
3
4
5
6
7
8
9
10
11
12
[root@jenkins2 ~]# cd /var/lib/jenkins/
[root@jenkins2 /var/lib/jenkins]# ll
drwxr-xr-x   4 root root    39 Nov  6 23:14 jobs  
drwxr-xr-x 132 root root 12288 Nov  1 18:51 plugins

jobs为每次构建后构建的结果目录
plugins为插件目录
cd /var/lib/jenkins/plugins
tar xf jenkins_plugins.tar.gz     解压手动上传的插件
rm -rf jenkins_plugins.tar.gz
mv plugins/* .
systemctl restart jenkins
  1. jenkins主要的目录
1
2
3
4
/usr/lib/jenkins/：jenkins安装目录，WAR包会放在这里
/etc/sysconfig/jenkins：jenkins配置文件，“端口”，“JENKINS_HOME”等都可以在这里配置
/var/lib/jenkins/：默认的JENKINS_HOME
/var/log/jenkins/jenkins.log：Jenkins日志文件

安装玩插件后变成中文版

创建一个自由风格的项目test‐job

丢弃旧的构建

返回jenkins主机生成密钥对

1
2
[root@jenkins2 ~]# ssh-keygen -t rsa
[root@jenkins2 ~]# cat .ssh/id_rsa.pub

将公钥放到gitlab服务器上

添加公钥

配置完成后点击保存，选择立即构建测试

查看创建的项目

1
2
3
4
5
6
7
8
[root@jenkins2 /var/lib/jenkins/workspace/test-job]# ll
total 388
-rw-r--r-- 1 root root   6398 Nov  7 02:38 awardrotate.js
drwxr-xr-x 2 root root   4096 Nov  7 02:38 images
-rw-r--r-- 1 root root  26696 Nov  7 02:38 index.html
-rw-r--r-- 1 root root  93628 Nov  7 02:38 jquery-1.10.2.js
-rw-r--r-- 1 root root 257551 Nov  7 02:38 jquery-2.2.4.js
-rw-r--r-- 1 root root   1334 Nov  7 02:38 README.md

SonarQube

介绍

  1. SonarQube基础java开发，需安装open JDK8版本
  2. SonarQube需要依赖MySQL数据库，至少5.6版本以上
  3. SonarQube的小型实例至少4G内存，如果大型实例需要16G内存

准备环境

安装jdk软件

1
2
rpm -ivh jdk-8u181-linux-x64.rpm
yum ‐y install git java unzip wget

安装数据库（略）

如果端口监听到tcp6，增加一条配置重启即可

1
2
[root@sonar ~]# grep bind /etc/my.cnf
bind‐address=0.0.0.0

或者关闭系统的tcp6

1
2
3
4
5
vim /etc/sysctl.conf  #加入以下三条配置
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1
sysctl -p

创建sonar库，并授权

1
2
create database sonar charset utf8;
show databases;

安装SonarQube

  1. 下载sonar 并使用sonar用户启动
1
2
3
4
unzip sonarqube-7.0.zip
mv sonarqube-7.0 /usr/local/
cd /usr/local/
ln -s sonarqube-7.0 sonarqube
  1. 创建用户sonar并授权
1
2
3
useradd sonar
chown -R sonar.sonar /usr/local/sonarqube
chown -R sonar.sonar /usr/local/sonarqube-7.0
  1. 配置sonar连接本地数据库
1
2
3
4
vim /usr/local/sonarqube/conf/sonar.properties
sonar.jdbc.username=root
sonar.jdbc.password=123
sonar.jdbc.url=jdbc:mysql://localhost:3306/sonar?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useConfigs=maxPerformance&useSSL=false
  1. 使用普通用户启动sonarqube
1
2
3
4
[root@sonar /usr/local]# su - sonar -c "/usr/local/sonarqube/bin/linux-x86-64/sonar.sh start"
Starting SonarQube...
Started SonarQube.
[root@sonar /usr/local]# netstat -lntup
  1. 启动sonar

启动后的端口为9000使用浏览器直接访问http://10.0.1.203:9000/about

用户名admin 密码admin，生成一个tokin,只显示一次记录好

配置管理sonar 安装插件

1.安装中文汉化插件

在页面上找到administrator > Marketplace > 搜索框 chinese，出现一个chinese pack 然后点击install，安装完点击 restart 重启生效

2.默认已安装C JAVA Python PHP JS 等代码质量分析工具

如果一个项目使用了JAVA CSS JS HTML ，默认情况下sonar只会检测JAVA,JS等代码的漏洞和bug，如果安装了HTML、CSS等插件，则会检测该项目代码中JAVA JS HTML CSS代码的漏洞和bug

手动安装插件

1
2
3
4
5
6
7
8
9
10
11
12
#备份源目录
mv /usr/local/sonarqube/extensions/plugins /usr/local/sonarqube/extensions/plugins_back
tar xf sonar_plugins.tar.gz -C /usr/local/sonarqube/extensions/
chown -R sonar.sonar /usr/local/sonarqube

#重启sonar服务
[root@sonar ~]# su - sonar -c "/usr/local/sonarqube/bin/linux-x86-64/sonar.sh restart"
Stopping SonarQube...
Waiting for SonarQube to exit...
Stopped SonarQube.
Starting SonarQube...
Started SonarQube.

重启后重新登陆，显示汉化完成

使用jenkins的test-job推送到web01测试

jenkins服务器测试推送html代码至SonarQube检测 下载客户端

客户端其他版本下载地址搜索对应版本 例如:SonarScanner 4.0

1
2
unzip sonar-scanner-cli-4.0.0.1744-linux.zip -d /usr/local/
cd /usr/local/ && ln -s sonar-scanner-4.0.0.1744-linux sonar-scanner

进入jenkins项目目录下推送测试

1
2
3
4
5
6
7
cd /var/lib/jenkins/workspace/test-job

/usr/local/sonar-scanner/bin/sonar-scanner \
  -Dsonar.projectKey=html \
  -Dsonar.sources=. \
  -Dsonar.host.url=http://10.0.1.203:9000 \
  -Dsonar.login=92668754d1dcfc3bc895e09e22ab15f44e2f04ec

进入sonar主页刷新后可以看到已推送成功

使用jenkins自动推送

到项目目录下进行代码推送分析 打开认证

将sonar集成到jenkins中需要安装插件，前面安装包已下载

进入jenkins主机编写脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
mkdir -p /server/scripts
cd /server/scripts/
[root@jenkins2 /server/scripts]# cat deploy.sh 
#!/bin/sh
DATE=$(date +%Y-%m-%d-%H-%M-%S)
#CODE_DIR="/var/lib/jenkins/workspace/my-freestyle-job"
CODE_DIR="${WORKSPACE}"
WEB_DIR="/code/www/"

get_code_tar(){
        cd $CODE_DIR && tar zcf /opt/web-$DATE.tar.gz ./*
}

scp_code_web(){
        scp /opt/web-$DATE.tar.gz 10.0.1.7:$WEB_DIR
}

code_tarxf(){
        ssh 10.0.1.7 "cd $WEB_DIR &&mkdir web-$DATE && tar xf web-$DATE.tar.gz -C web-$DATE"

}
ln_html(){
         ssh 10.0.1.7 "cd $WEB_DIR && rm -rf html && ln -s web-$DATE html"
}

main(){

        get_code_tar;
        scp_code_web;
        code_tarxf;
        ln_html;
}
main

jenkins把公钥分发给web01主机

1
ssh-copy-id -i /root/.ssh/id_rsa.pub 10.0.1.7

jenkins主机test-job重新部署

立即构建测试，推送成功

jenkins配置SonarQube

1）jenkins上配置SonarQube服务端

系统管理->系统设置->sonarQube 告诉jenkins SonarQubeServer服务端地址

  1. Name随意填写

  2. URL添加SonarQube的地址

  3. token添加一个secret text 填写之前安装SonarQube的Token

保存后，重新打开，添加用户

token添加一个secret text 填写之前安装SonarQube的Token，配置完成后保存

2) jenkins配置执行sonar-scanner命令的家目录

让jenkins能找到该命令 系统管理->全局工具配置

3）再次配置test-job的配置

Analysis properties项填写完保存执行，最后在SonarQube中查看结果

4)测试

查看sonar服务器，发现jenkins推送成功

jenkins推送java项目

推送java代码进行分析，使用以下方式

1
2
3
4
5
6
7
8
9
10
11
#方法1
cd /var/lib/jenkins/workspace/maven-job
/usr/local/sonar-scanner/bin/sonar-scanner \
-Dsonar.projectKey=java \
-Dsonar.sources=.

#方法2
cd /var/lib/jenkins/workspace/maven-job
mvn sonar:sonar \
  -Dsonar.host.url=http://10.0.1.203:9000 \
  -Dsonar.login=92668754d1dcfc3bc895e09e22ab15f44e2f04ec

环境准备

gitlab主机上新建一个项目

上传java项目到gitlab

1
2
3
4
5
6
7
tar xf hello-world-war.tar.gz
cd hello-world-war/

git remote -v
git remote remove origin 
git remote add origin git@10.0.1.200:oldboy/java.git
git push -u origin --all

web01上部署tomcat服务器

  1. 安装JDK
1
rpm -ivh jdk-8u181-linux-x64.rpm
  1. 安装TOMCAT
1
2
3
tar xf apache-tomcat-8.0.27.tar.gz -C /usr/local/
ln -s apache-tomcat-8.0.27 tomcat
/usr/local/tomcat/bin/startup.sh    --->启动tomcat
  1. 访问10.0.1.7:8080测试启动

创建一个maven-job项目

拉去gitlab的java项目

上传maven包

1
2
3
4
5
6
7
8
9
10
11
tar xf apache-maven-3.3.9-bin.tar.gz -C /usr/local/
cd /usr/local/
ln -s apache-maven-3.3.9 maven

vim /usr/local/maven/conf/settings.xml  #更改maven配置文件为阿里云下载
<mirror> 
<id>nexus-aliyun</id> 
<mirrorOf>*</mirrorOf> 
<name>Nexus aliyun</name> 
<url>http://maven.aliyun.com/nexus/content/groups/public</url> 
</mirror>

从gitlab克隆java项目

1
2
3
4
5
6
7
8
[root@jenkins2 ~]# git clone git@10.0.1.200:oldboy/java.git
[root@jenkins2 ~]# echo $PATH
[root@jenkins2 ~]# vim /etc/profile
export PATH='/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/usr/local/maven/bin'
[root@jenkins2 ~]# source /etc/profile
[root@jenkins2 ~]# cd java/
[root@jenkins2 ~/java]# mvn clean
[root@jenkins2 ~/java]# mvn package

返回设置jenkins上的maven配置

返回设置发现已经正常

jenkins编写tomcat的脚本

1
2
3
4
5
6
7
8
[root@jenkins2 /server/scripts]# cat tomcat.sh
#!/bin/bash
TIME=`date +%F`
WEB_DIR="/usr/local/tomcat/webapps"
ssh 10.0.1.7 "cd ${WEB_DIR} && mkdir ${TIME}-${BUTLD_ID}"
scp ${WORKSPACE}/target/*.war 10.0.1.7:${WEB_DIR}/${TIME}-${BUTLD_ID}
ssh 10.0.1.7 "cd ${WEB_DIR} && rm -rf ROOT && ln -s ${TIME}-${BUTLD_ID} ROOT"
ssh 10.0.1.7 "cd ${WEB_DIR}/ROOT && unzip *.war && rm -rf *.war"

保存后，立即构建测试

1
2
3
4
5
6
7
8
[root@web01 /usr/local/tomcat/webapps]# ll
total 4
drwxr-xr-x  4 root root   54 Nov  7 18:51 2019-11-07_
drwxr-xr-x 14 root root 4096 Nov  7 18:04 docs
drwxr-xr-x  6 root root   83 Nov  7 18:04 examples
drwxr-xr-x  5 root root   87 Nov  7 18:04 host-manager
drwxr-xr-x  5 root root  103 Nov  7 18:04 manager
lrwxrwxrwx  1 root root   11 Nov  7 18:51 ROOT -> 2019-11-07_

访问10.0.1.7:8080测试

java项目推送sonar

1
2
3
4
5
6
7
8
9
10
11
#方法1
cd /var/lib/jenkins/workspace/maven-job
/usr/local/sonar-scanner/bin/sonar-scanner \
-Dsonar.projectKey=java \
-Dsonar.sources=.

#方法2
cd /var/lib/jenkins/workspace/maven-job
mvn sonar:sonar \
  -Dsonar.host.url=http://10.0.1.203:9000 \
  -Dsonar.login=92668754d1dcfc3bc895e09e22ab15f44e2f04ec

进入jenkins主机手动推送测试

1
2
3
4
cd /var/lib/jenkins/workspace/maven‐job
mvn sonar:sonar \
‐Dsonar.host.url=http://10.0.1.203:9000 \
‐Dsonar.login=92668754d1dcfc3bc895e09e22ab15f44e2f04ec

访问10.0.1.203:9000测试

sonar客户端更改配置文件地址

1
2
3
4
[root@jenkins2 ~]# vim /usr/local/sonar-scanner/conf/sonar-scanner.properties
sonar.host.url=http://10.0.1.203:9000
sonar.login=92668754d1dcfc3bc895e09e22ab15f44e2f04ec
sonar.sourceEncoding=UTF-8

配置java项目，增加构建项sonar

  1. 方法一
1
2
3
4
5
Analysis properties 项填写(看项目选择第一个或第二个)
sonar.projectName=${JOB_NAME}
sonar.projectKey=java
sonar.sources=.
sonar.java.binaries=target/sonar

  1. 方法二
1
2
3
4
5
clean
verify
sonar:sonar
-Dsonar.host.url=http://10.0.1.203:9000 
-Dsonar.login=92668754d1dcfc3bc895e09e22ab15f44e2f04ec

构建成功后测试

jenkins集成企业微信

jenkins集成微信，工作中档git有新代码提交会触发钩子自动完成上线，运维和开发人员不须时刻盯着jenkins，通过微信的方式显示给运维和开发人员

1.注册微信企业公众号

搜索微信公众平台->注册->选择企业微信

选择完成后把下面信息进行完善->使用自己微信扫描二维码进行管理后-点注册

注册成功登陆后点击应用管理->创建应用

上次一张图片->填写应用名称-可见范围->创建应用-保存好agentld和secret写入py脚本

2.更改py脚本内对应的内容-touser为账号名称

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
[root@jenkins2 /server/scripts]# cat jenkins_notify.py 
#!/usr/bin/python2.7
#_*_coding:utf-8 _*_
 
 
import requests,sys,json
import urllib3
urllib3.disable_warnings()
 
reload(sys)
sys.setdefaultencoding('utf-8')
 
def GetToken(Corpid,Secret):
    Url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken"
    Data = {
        "corpid":Corpid,
        "corpsecret":Secret
    }
    r = requests.get(url=Url,params=Data,verify=False)
    Token = r.json()['access_token']
    return Token
 
def SendMessage(Token,Subject,Content, ProName):
    #Url = "https://qyapi.weixin.qq.com/cgi-bin/appchat/send?access_token=%s" % Token
    Url = "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=%s" % Token
    #Data = {
    #    "chatid": "JenkinsAlarm",  # 此处不明白请参考企业微信官网
    #    "msgtype": "text",
    #    "text": {
    #        "content": "[项目名称] : " + ProName + '\n' + "[项目地址] : " + Subject + '\n' + Content + '\n'
    #    },
    #    "safe": "0"
    #}
    data = {
        "touser" : "WuFei",
        "msgtype" : "text",
        "agentid" : 1000002,
        "text" : {
           "content" : "[项目名称] : " + ProName + '\n' + "[项目地址] : " + Subject + '\n' + 
Content + '\n'
        },
        "safe":0
    }
    r = requests.post(url=Url,data=json.dumps(data),verify=False)
    return r.text
 
def action_from_file(filename):
    try:
        str1 = '[变更日志] : '
        with open(filename, 'r') as f:
            for i in f.readlines():
                str1 += i
print str1
        if len(str1) == 17:
            str1 += " 无变更"
# print str1
        return str1
    except Exception as e:
        #print('[ERROR] {0}'.format(e))
str1 += str(e)
 
 
if __name__ == '__main__':
    Corpid = "ww92914ec6b1198c60"
    Secret = "N7uT7xiIAipasfOYSs9QQ5LcNqwPqooi6beJT1P7x-Y"
 
    Subject = sys.argv[1]
    Content = action_from_file(sys.argv[2])
    ProName = sys.argv[3]
 
    Token = GetToken(Corpid, Secret)
    Status = SendMessage(Token,Subject,Content,ProName)
    print Status

Corpid为企业ID 这里只把corpid写入对应的位置

3.完成后配置jenkins

1.下载安装插件

由于jenkins没有官网的插件来完成此功能，所以我们只能用网络上一些开源的插件（线下班不需要以下步骤，已集合在plugins）

github下载代码：https://github.com/daniel-beck/changelog-environment-plugin

解压到某个目录-》进入目录执行以下操作

cd 到 changelog-environment-plugin-master 下，执行 mvn verify

时间较长，会在changelog-environment-plugin-master/target/下有个changelog-environment.hpi文件，上传到jenkins即可使用

2.配置jenkins的test-job

jenkins进入到项目中->构建环境多了Add Changelog Information to Environment->点击选择

1
2
3
4
5
Entry Format   
%3$s(at %4$s via %1$s)    参数分别为ChangeLog内容，时间，提交人

Date Format
yyyy‐MM‐dd HH:mm:ss       就是时间格式

构建后操作选择Post build task

# 如果没有此选择请安装Hudson Post build task 插件，SCM_CHANGELOG须安装changelog插件

1
2
3
4
echo "==========Start Notify=============="
echo ${SCM_CHANGELOG} > /tmp/${JOB_NAME}_change.log
python /server/scripts/jenkins_notify.py ${BUILD_URL} /tmp/${JOB_NAME}_change.log ${JOB_NAME}
rm ‐fv /tmp/${JOB_NAME}_change.log

3.上传py脚本->jenkins服务器上安装python requests模块

1
2
3
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
yum -y install python-pip
pip2.7 install requests

4.打开构建触发器

5.gitlab克隆项目修改并推送

1
2
3
4
git clone git@10.0.1.200:oldboy/dzp.git
cd dzp/
git commit -am "修改测试微信消息"
git push -u origin master

6.jenkins上构建测试消息

企业微信收到信息

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 4.Maven+jeesns http://linuxwf.com/2020/04/15/4-Maven-jeesns/ 2020-04-15T08:40:00.000Z 2020-04-15T08:41:37.000Z

Maven+jeesns项目

第1章 Maven介绍

Maven是一个项目管理和综合工具。Maven提供给开发人员构建一个完整的生命周期框架。

开发团队可以自动完成该项目的基础设施建设，Maven使用标准的目录结构和默认构建生命周期。

Apache的开源项目主要服务于JAVA平台的构建、依赖管理、项目管理。

Project Object Model，项目对象模型。通过xml格式保存的pom.xml文件。该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。该文件是由开发维护，我们运维人员可以不用去关心。

第2章 安装部署

  1. 下载Maven 3安装包
    官网：http://maven.apache.org/download.cgi
    清华镜像：https://mirrors.tuna.tsinghua.edu.cn/apache/maven/

  2. 安装Maven

1
2
3
4
tar xf apache‐maven‐3.3.9‐bin.tar.gz
mv apache‐maven‐3.3.9 /usr/local/
ln ‐s /usr/local/apache‐maven‐3.3.9/ /usr/local/maven
/usr/local/maven/bin/mvn ‐v
  1. 编辑/etc/profile文件
1
2
3
export PATH=/usr/local/apache-maven-3.3.9/bin/:$PATH
source /etc/profile
mvn ‐v 查看版本号

#进入目录执行打包命令

1
2
3
4
5
6
7
8
9
validate（验证）: 验证项目正确，并且所有必要信息可用。
compile（编译）: 编译项目源码
test（测试）: 使用合适的单元测试框架测试编译后的源码。
package（打包）: 源码编译之后，使用合适的格式（例如JAR格式）对编译后的源码进行打包。
integration‐test（集成测试）: 如果有需要，把包处理并部署到可以运行集成测试的环境中去。
verify（验证）: 进行各种测试来验证包是否有效并且符合质量标准。
install（安装）: 把包安装到本地仓库，使该包可以作为其他本地项目的依赖。
deploy（部署）: 在集成或发布环境中完成，将最终软件包复制到远程存储库，以与其他开发人员和项目共享。
mvn clean (清除) : 清除上次编译的结果

1.上传一个简单的java项目apache-tomcat-8.0.27.tar.gz，并安装及创建数据库

1
2
3
mkdir /applocation
tar xf apache-tomcat-8.0.27.tar.gz
mv apache-tomcat-8.0.27 /applocation/tomcat

tomcat启动加速的方法

1
2
3
4
vim /usr/java/jdk1.8.0_181‐amd64/jre/lib/security/java.security
修改117行为：securerandom.source=file:/dev/urandom
/applocation/tomcat/bin/startup.sh     #启动tomcat
netstat -tunlp

数据库准备

1
2
3
4
5
6
yum -y install mariadb-server
systemctl start mariadb.service
netstat -tunlp
mysqladmin password oldboy
mysql -uroot -poldboy
MariaDB [(none)]> create database jeesns;   #创建数据库

2.在gitlab上创建jeesns项目

3.在gitlab-200主机解压jeesns，并上传代码到gitlab

1
2
3
4
5
6
7
8
9
10
11
12
1.解压jeesns包，并修改mysql密码
tar xf jeesns.tar.gz
cd jeesns
grep -r "mysql"
cat jeesns-web/src/main/resources/jeesns.properties
jdbc.password=oldboy      #更改mysql登录密码

2.创建仓库并上传代码
git remote add origin git@10.0.1.200:oldboy/jeesns.git  
git add .
git commit -am "xxx"
git push -u origin master

4.在jenkins主机上克隆代码，并导入数据库

1
2
3
4
5
6
1.克隆代码
git clone git@10.0.1.200:oldboy/jeesns.git    

2.导入数据库
[root@jenkins-201 ~]# scp /var/lib/jenkins/workspace/jeesns-job/jeesns-web/database/jeesns.sql 10.0.1.7:/root/
 mysql ‐uroot ‐proot jeesns </tmp/jeesns.sql

5.配置jenkins

系统管理-全局工具配置-maven安装

6.新建Item jeesns-job

第3章 tomcat网页测试

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 3.jenkins安装部署 http://linuxwf.com/2020/04/15/3-jenkins%E5%AE%89%E8%A3%85%E9%83%A8%E7%BD%B2/ 2020-04-15T08:34:00.000Z 2020-04-15T08:35:24.000Z

Jenkins安装部署

第1章 jenkins介绍

Jenkins是一个开源软件项目，是基于Java开发的一种持续集成工具，用于监控持续重复的工作，旨在提供一个开放易用的软件平台，使软件的持续集成变成可能。

官网 ：https://jenkins.io

第2章 准备环境

jenkins 10.0.0.201

1
2
3
4
5
6
7
[root@jenkins-201 ~]# cat /etc/redhat-release
CentOS Linux release 7.4.1708 (Core)
[root@jenkins-201 ~]# uname -r
3.10.0-693.el7.x86_64
[root@jenkins-201 ~]# getenforce
Disabled
[root@jenkins-201 ~]# systemctl stop firewalld

第3章 安装部署

3.1 安装JDK运行环境和jenkins服务

1
2
rpm ‐ivh jdk‐8u181‐linux‐x64.rpm
rpm ‐ivh jenkins‐2.99‐1.1.noarch.rpm

3.2 配置jenkins

启动用户修改为root

1
2
3
4
[root@jenkins-201 ~]# grep "JENKINS_USER" /etc/sysconfig/jenkins
JENKINS_USER="root"
[root@jenkins-201 ~]# systemctl start jenkins
[root@jenkins-201 ~]# systemctl enable jenkins

3.3 打开页面配置

3.4 插件安装

（跳过安装插件，直接上传插件到目录）和修改登录密码

  1. 自动安装可选插件
  2. 手动下载插件上传安装
  3. 插件放入插件目录
1
2
3
4
5
[root@jenkins-201 ~]# cd /var/lib/jenkins/
[root@jenkins-201 ~]#ll   #jobs为每次构建后构建的结果目录，plugins为插件目录
drwxr-xr-x 97 root root      8192 Sep  4 22:32 plugins
​
#上传插件包解压到plugins下执行重启 systemctl restart jenkins
  1. jenkins主要的目录
1
2
3
4
5
/usr/lib/jenkins/：jenkins安装目录，WAR包会放在这里
/etc/sysconfig/jenkins：jenkins配置文件，“端口”，“JENKINS_HOME”等都可以在这里配置
/var/lib/jenkins/：默认的JENKINS_HOME
/var/log/jenkins/jenkins.log：Jenkins日志文件
/etc/sysconfig/jenkins：jenkins配置文件，“端口”，“JENKINS_HOME”等都可以在这里配置
  1. 创建一个自由风格的项目freestyle‐job

丢失旧的构建

执行一条shell命令、查看运行的当前路径,构建后的产物存在/var/lib/jenkins/workspace/

  1. jenkins获取git源码

这里我们有码云导入一个HTML页面的监控平台到gitlab仓库

jenkins端配置从git获取代码，由于我们dev用户是配置在jenkins上，所以无需认证即可下载代码

  1. 执行立即构建获取到代码

  1. 写一个脚本把从git仓库里获取的代码上传到web服务器站点目录下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
[root@jenkins-201 /server/scripts]# cat deploy.sh 
#!/bin/bash
CODEDIR=/var/lib/jenkins/workspace/freestyle-job/
TIME=`date +%F-%H-%M-%S`
IP=10.0.1.7
TAR(){
cd $CODEDIR
tar zcf /opt/web-${TIME}.tar.gz ./*
}
CP(){
scp /opt/web-${TIME}.tar.gz $IP:/code/
}

XF(){
ssh $IP "cd /code && mkdir web-$TIME"
ssh $IP "cd /code && tar xf web-${TIME}.tar.gz -C web-$TIME"
ssh $IP "rm -rf /code/web-${TIME}.tar.gz"
}

LN(){
        ssh $IP "rm -rf /code/www && ln -s /code/web-$TIME /code/www"
}

main(){
TAR
CP
XF
LN
}
main
  1. 使用jenkins调用部署脚本（此处写脚本全路径脚本名称）测试

  1. 配置自动触发构建、需要设置安全令牌Secret token

  1. 克隆代码到master上更改代码后进行推送测试是否自动触发
1
git clone git@10.0.1.200:oldboy/dzp.git
  1. Jenkins配置jenkins返回构建状态到gitlab

系统管理‐系统设置选项下

进行认证配置进入gitlab点击用户设置找到访问令牌Access Tokens

下一步设置项目中的执行后操作。然后进行构建测试返回结果

查看测试结果

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 2.gitlab安装部署 http://linuxwf.com/2020/04/15/2-gitlab%E5%AE%89%E8%A3%85%E9%83%A8%E7%BD%B2/ 2020-04-15T07:54:00.000Z 2020-04-15T08:38:20.000Z

gitlab安装部署

第一章 简介

GitLab 是一个用于仓库管理系统的开源项目。使用Git作为代码管理工具，并在此基础上搭建起来的web服务。可 通过Web界面进行访问公开的或者私人项目。它拥有与Github类似的功能，能够浏览源代码，管理缺陷和注释。可 以管理团队对仓库的访问，它非常易于浏览提交过的版本并提供一个文件历史库。团队成员可以利用内置的简单聊 天程序(Wall)进行交流。它还提供一个代码片段收集功能可以轻松实现代码复用。

常用的网站： 官网：https://about.gitlab.com/

国内镜像：https://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el7/

第2章 gitlab安装部署

1
2
3
4
5
#git官网
https://about.gitlab.com/installation/#centos‐7

#安装依赖
yum install -y curl policycoreutils-python openssh-server openssh-clients postfix cronie

安装

1
2
3
4
5
# mkdir -p /home/oldboy/tools

# cd /home/oldboy/tools

# rz -bye gitlab-ce-10.2.2-ce.0.el7.x86_64.rpm # 上传gitlab安装包 下载方式可通过国内清华源gitlab-ce社区版本下载

配置

1
2
3
4
5
6
7
8
9
# vim /etc/gitlab/gitlab.rb       # gitlab 配置文件更改url地址为本机IP地址 external_url 'http://10.0.1.200'
gitlab-ctl reconfigure            # 更改配置文件后需重新配置
/opt/gitlab/                  # gitlab的程序安装目录
/var/opt/gitlab               # gitlab目录数据目录
/var/opt/gitlab/git-data     # 存放仓库数据
gitlab‐ctl status             # 查看目前gitlab所有服务运维状态
gitlab‐ctl stop               # 停止gitlab服务
gitlab‐ctl stop nginx         # 单独停止某个服务
gitlab‐ctl tail               # 查看所有服务的日志

通过浏览器输入IP地址进行访问gitlab

1
2
3
4
5
6
7
8
9
10.0.1.200
Gitlab的服务构成：
nginx： 静态web服务器
gitlab‐workhorse: 轻量级的反向代理服务器
logrotate：日志文件管理工具
postgresql：数据库
redis：缓存数据库
sidekiq：用于在后台执行队列任务（异步执行）。（Ruby）
unicorn：An HTTP server for Rack applications，GitLab Rails应用是托管在这个服务器上面的。（RubyWeb Server,主要使用Ruby编写）

gitlab汉化

  1. 停止服务器
1
# gitlab‐ctl stop
  1. 下载汉化补丁
1
# git clone https://gitlab.com/xhang/gitlab.git
  1. 查看gitlab版本信息及汉化版本
1
2
# head -1 /opt/gitlab/version-manifest.txt 
# cat /root/gitlab/VERSION
  1. 对比版本、生成补丁包
1
2
# cd gitlab 
# git diff v10.2.2 v10.2.2-zh  > /root/10.2.2-zh.diff
  1. 打补丁
1
2
# yum -y install patch 
# patch ‐d /opt/gitlab/embedded/service/gitlab‐rails ‐p1 < /tmp/10.2.2‐zh.diff
  1. 启动和重新配置
1
# gitlab‐ctl start # gitlab-ctl reconfigure

第3章 gitlab使用

1.配置外观

管理区域‐外观

2.关闭自动注册

可根据实际需求操作 管理区域‐设置‐关闭自动注册

3.创建组‐用户‐项目

创建组

设置组名称、描述等创建群组

创建用户

编辑密码

4.把用户添加到组里面

管理区域-选择创建的oldboy组进行添加用户、权限给开发人员-增加用户到群组

gitlab添加用户自动邮件通知

-检查postfix状态

1
systemctl status postfix

-编辑gitlab的配置文件，打开邮件通知

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
gitlab-ctl stop
vim /etc/gitlab/gitlab.rb
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.qq.com"
gitlab_rails['smtp_port'] = 465
gitlab_rails['smtp_user_name'] = "wufei008@qq.com"   #你自己QQ号
gitlab_rails['smtp_password'] = "xxxxxxxxx"          #QQ授权码
gitlab_rails['smtp_domain'] = "smtp.qq.com"
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['smtp_tls'] = true
gitlab_rails['gitlab_email_from'] = 'wufei008@qq.com' #你自己QQ号

gitlab-ctl start
gitlab-ctl reconfigure

-测试邮箱是否正常发送

执行 gitlab-rails console进入控制台交互界面, 然后在控制台提示符后输入下面内容发送一封测试邮件，测试完成后exit()退出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
[root@gitlab ~]# gitlab-rails console
--------------------------------------------------------------------------------
 GitLab:       12.3.5 (2417d5becc7)
 GitLab Shell: 10.0.0
 PostgreSQL:   10.9
--------------------------------------------------------------------------------
Loading production environment (Rails 5.2.3)
irb(main):001:0> Notify.test_email('wufei008@qq.com', '邮件标题_test', '邮件正文_test').deliver_now 
Notify#test_email: processed outbound mail in 0.7ms
Sent mail to wufei008@qq.com (1344.4ms)
Date: Thu, 05 Dec 2019 18:57:37 +0800
From: GitLab <wufei008@qq.com>
Reply-To: GitLab <noreply@192.168.124.200>
To: wufei008@qq.com
Message-ID: <5de8e2a1858a1_7993f8fddccf98c6189e@gitlab.mail>
Subject: =?UTF-8?Q?=E9=82=AE=E4=BB=B6=E6=A0=87=E9=A2=98=5Ftest?=
Mime-Version: 1.0
Content-Type: text/html;
 charset=UTF-8
Content-Transfer-Encoding: 7bit
Auto-Submitted: auto-generated
X-Auto-Response-Suppress: All

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
<html><body><p>&#37038;&#20214;&#27491;&#25991;_test</p></body></html>

=> #<Mail::Message:69886775708240, Multipart: false, Headers: <Date: Thu, 05 Dec 2019 18:57:37 +0800>, <From: GitLab <wufei008@qq.com>>, <Reply-To: GitLab <noreply@192.168.124.200>>, <To: wufei008@qq.com>, <Message-ID: <5de8e2a1858a1_7993f8fddccf98c6189e@gitlab.mail>>, <Subject: 邮件标题_test>, <Mime-Version: 1.0>, <Content-Type: text/html; charset=UTF-8>, <Content-Transfer-Encoding: 7bit>, <Auto-Submitted: auto-generated>, <X-Auto-Response-Suppress: All>>
irb(main):002:0> exit

5.创建仓库

管理区域-创建仓库

6.登陆dev用户测试是否能看到空的git‐test仓库

7.添加ssh‐keys到gitlab

注：一个服务器的key只能添加到一个gitlab服务器上，一个用户可以添加多个key

1
ssh-keygen -t rsa

8.添加远程仓库、推送本地代码到远程仓库

1
2
3
4
5
git remote add origin git@10.0.1.200:oldboy/git_data.git   # 添加远程仓库

git remote rename origin old‐origin # 远程 origin 如果已经存在则重新命名或者新添加仓库名称不同

git push ‐u origin ‐‐all # 推送代码到远程仓库

9.克隆代码到另外一台主机

如果不做认证会让输入gitlab的密码、我们使用key进行认证

1
ssh-keygen -t rsa

把公钥复制到dev用户下进行测试

然后在克隆代码

1
git clone git@10.0.1.200:oldboy/git_data.git

测试推送代码到dev下

1
2
3
4
5
6
git branch dev 
git checkout dev 
touch dev 
git add . 
git commit ‐m "add dev" 
git push ‐u origin dev # 推送dev分支到远程仓库

提交合并请求进行分支合并到master主分支

合并后在gitlab服务端master上没有dev、要先进行pull

1
2
cd /root/git_data 
git pull

9.设置保护主分支

测试dev分支推送代码则显示为拒绝，如果还是可以推送请查看配置保护分支选项

1
2
3
git checkout master 
git merge dev 
git push ‐u origin master

10.返回master端测试推送

由于其他分支进行推送，和master端内容不一致，所以无法进行推送，使用git pull把代码拉取到本地，或者git fetch把代码拉取到本地仓库后进行合并（注意：git pull = git fetch+git merge）

11.dev分支发起合并流程

dev分支提交代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[root@jenkins2 ~/git_data]# git branch 
* dev
  master
[root@jenkins2 ~/git_data]# echo dd > dd.txt
[root@jenkins2 ~/git_data]# git add .
[root@jenkins2 ~/git_data]# git commit -m "add dd.txt"
[dev 77010d9] add dd.txt
 1 file changed, 1 insertion(+)
 create mode 100644 dd.txt
[root@jenkins2 ~/git_data]# git push -u origin dev
Counting objects: 4, done.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 256 bytes | 0 bytes/s, done.
Total 3 (delta 1), reused 0 (delta 0)
remote: 
remote: View merge request for dev:
remote:   http://10.0.1.200/oldboy/git_data/merge_requests/5
remote: 
To git@10.0.1.200:oldboy/git_data.git
   eeb87fd..77010d9  dev -> dev
Branch dev set up to track remote branch dev from origin.

代码提交后，dev用户登录gitlab提交合并请求

root用户进行合并

查看master主分支，发现已合并

第4章 gitlab备份

对gitlab进行备份将会创建一个包含所有库和附件的归档文件。对备份的恢复只能恢复到与备份时的gitlab相同的版本。将gitlab迁移到另一台服务器上的最佳方法就是通过备份和还原。

gitlab提供了一个简单的命令行来备份整个gitlab，并且能灵活的满足需求。

备份文件将保存在配置文件中定义的backup_path中，文件名为TIMESTAMP_gitlab_backup.tar,

TIMESTAMP为备份时的时间戳。TIMESTAMP的格式为：EPOCH_YYYY_MM_DD_Gitlab‐version。

如果自定义备份目录需要赋予git权限

配置文件中加入

1
2
3
gitlab_rails['backup_path'] = "/var/opt/gitlab/backups" 
gitlab_rails['backup_keep_time'] = 604800 #备份保留的时间（以秒为单位，这个是七天默认值）
gitlab‐ctl reconfigure #完成后执行

4.1 手动备份

执行：gitlab-rake gitlab:backup:create生成一次备份

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
[root@gitlab-200 ~]# gitlab-rake gitlab:backup:create
Dumping database ... 
Dumping PostgreSQL database gitlabhq_production ... [DONE]
done
Dumping repositories ...
 * oldboy/git_data ... [DONE]
 * oldboy/git_data.wiki ...  [SKIPPED]
done
Dumping uploads ... 
done
Dumping builds ... 
done
Dumping artifacts ... 
done
Dumping pages ... 
done
Dumping lfs objects ... 
done
Dumping container registry images ... 
[DISABLED]
Creating backup archive: 1567562451_2019_09_04_10.2.2_gitlab_backup.tar ... done
Uploading backup archive to remote storage  ... skipped
Deleting tmp directories ... done
done
done
done
done
done
done
done
Deleting old backups ... done. (0 removed)

4.2 定时备份

在定时任务里添加：

1
2
#定时备份gitlab
0 2 * * *  /usr/bin/gitlab-rake gitlab:backup:create  >/dev/null 2>&1

4.3 恢复

只能还原到与备份文件相同的gitlab版本。

执行恢复操作时，需要gitlab处于运行状态，备份文件位于gitlab_rails['backup_path']

1
2
[root@gitlab-200 ~]# ll /var/opt/gitlab/backups/
-rw------- 1 git git 204800 Sep  4 10:00 1567562451_2019_09_04_10.2.2_gitlab_backup.tar

停止连接到数据库的进程（也就是停止数据写入服务），但是保持GitLab是运行的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[root@gitlab-200 ~]# gitlab-ctl stop unicorn
ok: down: unicorn: 1s, normally up
[root@gitlab-200 ~]#  gitlab-ctl stop sidekiq
ok: down: sidekiq: 0s, normally up
[root@gitlab-200 ~]# gitlab-ctl status    #确认状态
run: gitaly: (pid 11111) 18801s; run: log: (pid 1040) 23368s
run: gitlab-monitor: (pid 11149) 18785s; run: log: (pid 1138) 23367s
run: gitlab-workhorse: (pid 11166) 18781s; run: log: (pid 1038) 23368s
run: logrotate: (pid 25081) 2346s; run: log: (pid 1044) 23368s
run: nginx: (pid 11187) 18777s; run: log: (pid 1036) 23369s
run: node-exporter: (pid 11190) 18776s; run: log: (pid 1052) 23369s
run: postgres-exporter: (pid 11193) 18775s; run: log: (pid 1147) 23368s
run: postgresql: (pid 11207) 18773s; run: log: (pid 1042) 23369s
run: prometheus: (pid 11217) 18771s; run: log: (pid 1139) 23368s
run: redis: (pid 11225) 18770s; run: log: (pid 1046) 23369s
run: redis-exporter: (pid 11264) 18770s; run: log: (pid 1143) 23368s
down: sidekiq: 8s, normally up; run: log: (pid 1048) 23369s
down: unicorn: 19s, normally up; run: log: (pid 1035) 23369s

接下我们进行恢复，指定时间戳你要从那个备份恢复：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
gitlab-rake gitlab:backup:restore BACKUP=1567562451_2019_09_04_10.2.2  #恢复
Unpacking backup ... done
Before restoring the database, we will remove all existing
tables to avoid future upgrade problems. Be aware that if you have
custom tables in the GitLab database these tables and all data will be
removed.

Do you want to continue (yes/no)?  #将移除我们自建的表。回答yes
Restoring uploads ... 
done
Restoring builds ... 
done
Restoring artifacts ... 
done
Restoring pages ... 
done
Restoring lfs objects ... 
done
This will rebuild an authorized_keys file.
You will lose any data stored in authorized_keys file.
Do you want to continue (yes/no)? #将移除所有的认证Key。回答yes
....
Deleting tmp directories ... done
done
done
done
done
done
done
done

[root@gitlab-200 ~]# gitlab-ctl restart  #完成后重启GitLab服务
ok: run: gitaly: (pid 29450) 0s
ok: run: gitlab-monitor: (pid 29466) 1s
ok: run: gitlab-workhorse: (pid 29469) 0s
ok: run: logrotate: (pid 29477) 0s
ok: run: nginx: (pid 29483) 0s
ok: run: node-exporter: (pid 29488) 1s
ok: run: postgres-exporter: (pid 29492) 0s
ok: run: postgresql: (pid 29514) 0s
ok: run: prometheus: (pid 29522) 0s
ok: run: redis: (pid 29527) 1s
ok: run: redis-exporter: (pid 29558) 0s
ok: run: sidekiq: (pid 29573) 1s
ok: run: unicorn: (pid 29580) 0s


检查GitLab的服务

[root@gitlab-200 ~]# gitlab-rake gitlab:check SANITIZE=true
Checking GitLab Shell ...

GitLab Shell version >= 5.9.4 ? ... OK (5.9.4)
Repo base directory exists?
default... yes
Repo storage directories are symlinks?
default... no
Repo paths owned by git:root, or git:git?
default... yes
Repo paths access is drwxrws---?
default... yes
hooks directories in repos are links: ... 
2/1 ... ok
Running /opt/gitlab/embedded/service/gitlab-shell/bin/check
Check GitLab API access: OK
Redis available via internal API: OK

Access to /var/opt/gitlab/.ssh/authorized_keys: OK
gitlab-shell self-check successful

Checking GitLab Shell ... Finished

Checking Sidekiq ...

Running? ... yes
Number of Sidekiq processes ... 1

Checking Sidekiq ... Finished

Reply by email is disabled in config/gitlab.yml
Checking LDAP ...

LDAP is disabled in config/gitlab.yml

Checking LDAP ... Finished

Checking GitLab ...

Git configured correctly? ... yes
Database config exists? ... yes
All migrations up? ... yes
Database contains orphaned GroupMembers? ... no
GitLab config exists? ... yes
GitLab config up to date? ... yes
Log directory writable? ... yes
Tmp directory writable? ... yes
Uploads directory exists? ... yes
Uploads directory has correct permissions? ... yes
Uploads directory tmp has correct permissions? ... yes
Init script exists? ... skipped (omnibus-gitlab has no init script)
Init script up-to-date? ... skipped (omnibus-gitlab has no init script)
Projects have namespace: ... 
2/1 ... yes
Redis version >= 2.8.0? ... yes
Ruby version >= 2.3.5 ? ... yes (2.3.5)
Git version >= 2.7.3 ? ... yes (2.13.6)
Git user has default SSH configuration? ... yes
Active users: ... 2

Checking GitLab ... Finished
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 1.DevOps http://linuxwf.com/2020/04/15/1-DevOps/ 2020-04-15T07:23:00.000Z 2020-04-15T07:24:57.000Z

DevOps

第1章 什么是DevOps

开发 development

运维 operations

1.1 DevOps能做什么？

提高产品质量
1 自动化测试
2 持续集成
3 代码质量管理工具
4 程序员鼓励师

1.2 Devops如何实现

既然这么好？为什么有些公司没有
设计架构规划‐代码的存储‐构建‐测试、预生产、部署、监控

第2章 Git版本控制系统

2.1 版本控制系统简介

一个标准的版本控制系统 Version Control System (VCS)，通常需要有以下功能：

  • 能够创建 Repository (仓库)，用来保存代码
  • 协同开发时方便将代码分发给团队成员
  • 记录每次修改代码的内容、时间、原因等信息
  • 能够创建 Branch (分支)，可以根据不同的场景进行开发
  • 能够创建 Tag (标签)，建立项目里程碑

2.2 为什么需要版本控制

在软件开发过程，每天都会产生新的代码，代码合并的过程中可能会出现如下问题：

  • 代码被覆盖或丢失
  • 代码写的不理想希望还原之前的版本
  • 希望知道与之前版本的差别
  • 是谁修改了代码以及为什么修改
  • 发版时希望分成不同的版本(测试版、发行版等)

因此，我们希望有一种机制，能够帮助我们：

  • 可以随时回滚到之前的版本
  • 协同开发时不会覆盖别人的代码
  • 留下修改记录，以便随时查看
  • 发版时可以方便的管理不同的版本

2.3 常见版本管理工具

Cvs：是一个C/S系统,是一个常用的代码版本控制软件。主要在开源软件管理中使用。多个开发人员通过一个中心版本控制系统来记录文件版本，从而达到保证文件同步的目的。是一种很古老的版本控制工具了，但是是很典型的集中式版本控制工具

SVN： 是一个开放源代码的版本控制系统，相较于RCS、CVS，它采用了分支管理系统，它的设计目标就是取代CVS。可以说是集中式版本控制的集大成者

Git： 是一个开源的分布式版本控制系统，可以有效、高速的处理从很小到非常大的项目版本管理。是一种分布式的版本控制工具

GitHub：gitHub是一个面向开源及私有软件项目的托管平台,因为只支持git 作为唯一的版本库格式进行托管,故名gitHub。

2个概念：

分布式版本控制：分布式的版本控制就是每个人都可以创建一个独立的代码仓库用于管理，各种版本控制的操作都可以在本地完成。每个人修改的代码都可以推送合并到另外一个代码仓库中。

集中式版本控制：只有一个中央控制，所有的开发人员都必须依赖于这个代码仓库。每次版本控制的操作也必须链接到服务器才能完成。所以很多公司喜欢用集中式的版本控制是为了更好的控制代码。如果个人开发，就可以选择Git这种分布式的。并不存在那个更加好或者其他的。

第3章 Git安装部署

3.1 系统环境准备

1
2
3
4
5
6
7
[root@gitlab-200 ~]# cat /etc/redhat-release    #查看系统版本
CentOS Linux release 7.4.1708 (Core) 
[root@gitlab-200 ~]# uname -r                   #查看系统内核
3.10.0-693.el7.x86_64 
[root@gitlab-200 ~]# getenforce                 #关闭SElinux
Disabled
[root@gitlab-200 ~]# systemctl stop firefalld   #关闭防火墙

3.2 安装部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[root@gitlab-200 ~]# yum -y install git      #安装git
[root@git ~]# git config
‐‐global                         #使用全局配置文件
‐‐system                         #使用系统级配置文件
‐‐local                          #使用版本库级配置文件
[root@gitlab-200 ~]# git config –‐global user.name ‘wufei’  
# 配置git使用账户
[root@gitlab-200 ~]# git config –‐global user.email ‘wufei008@qq.com’ 
# 配置git使用邮箱
[root@gitlab-200 ~]# git config –‐global color.ui true
# 语法高亮
[root@gitlab-200 ~]# git config --list     #查看git用户信息
user.name=wufei
user.email=wufei008@qq.com
color.ui=true
[root@gitlab-200 ~]# cat .gitconfig 
[user]
name = wufei
email = wufei008@qq.com
[color]
ui = true

3.3 Git初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#初始化工作目录、对已存在的目录或者对已存在的目录都可进行初始化
[root@gitlab-200 ~]# mkdir /git_date
[root@gitlab-200 ~]# cd /git_date/
[root@gitlab-200 /git_date]# git init    #初始化工作目录
[root@gitlab-200 /git_date]# git status   # 查看工作区状态
#隐藏文件介绍
[root@gitlab-200 /git_date]# tree -L 1 .git/    
.git/
├── branches                #分支目录
├── COMMIT_EDITMSG
├── config                  #定义项目特有的配置选项
├── description             #仅供git web程序使用
├── HEAD                    #指示当前的分支
├── hooks                   #包含git钩子文件
├── index                   #保存暂存区信息，在执行git init的时候，这个文件还没有
├── info                    #包含一个全局排除文件(exclude文件)
├── logs
├── objects                 #存放所有数据内容，有info和pack两个子文件夹
├── ORIG_HEAD
└── refs                    #存放指向数据(分支)的提交对象的指针

3.4 Git常规使用

3.4.1 创建数据-提交数据

3.4.2 git四种状态

git库所在的文件夹中的文件大致有4种状态

  • Untracked: 未跟踪, 此文件在文件夹中, 但并没有加入到git库, 不参与版本控制. 通过git add 状态变为Staged.
  • Unmodify: 文件已经入库, 未修改, 即版本库中的文件快照内容与文件夹中完全一致. 这种类型的文件有两种去处, 如果它被修改, 而变为Modified. 如果使用git rm移出版本库, 则成为Untracked文件
  • Modified: 文件已修改, 仅仅是修改, 并没有进行其他的操作. 这个文件也有两个去处, 通过git add可进入暂存staged状态, 使用git checkout 则丢弃修改过, 返回到unmodify状态, 这个git checkout即从库中取出文件, 覆盖当前修改
  • Staged: 暂存状态. 执行git commit则将修改同步到库中, 这时库中的文件和本地文件又变为一致, 文件为Unmodify状态. 执行git reset HEAD filename取消暂存, 文件状态为Modified

3.4.3 git基础命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
[root@gitlab-200 /git_date]# git status
# On branch master                            #位于分支 master
nothing to commit, working directory clean    
#无文件要提交（创建/拷贝文件并使用 "git add" 建立跟踪）
[root@gitlab-200 /git_date]# touch a b c
[root@gitlab-200 /git_date]# git status
# 位于分支 master
#
# 初始提交
#
# 未跟踪的文件:
# （使用 "git add <file>..." 以包含要提交的内容）
#
# a
# b
# c
#提交为空，但是存在尚未跟踪的文件（使用 "git add" 建立跟踪）
[root@gitlab-200 /git_date]# git add a  
[root@gitlab-200 /git_date]# git add .           
#使用git add . 或者* 添加目录中所有改动过的文件

[root@gitlab-200 /git_date]# git rm ‐‐cached c    #撤销操作 从暂存区删除文件
#删除文件步骤：
1.先从暂存区撤回到工作区、然后直接删除文件
git rm ‐‐cached c
rm ‐f c
2.直接从暂存区域同工作区域一同删除文件命令
git rm -f b
[root@gitlab-200 /git_date]# git commit ‐m "add newfile a" #提交到本地仓库

#修改文件名称两种方法
1.
[root@gitlab-200 /git_date]# mv a a.txt
[root@gitlab-200 /git_date]# git add a.txt
[root@gitlab-200 /git_date]# git commit ‐m "commit a.txt"
[root@gitlab-200 /git_date]# git status
2.直接用git命令重命名
[root@gitlab-200 /git_date]# git mv a.txt a
[root@gitlab-200 /git_date]# git status
[root@gitlab-200 /git_date]# git commit ‐m "rename a.txt a"
#git status 只能查看区域状态的不同，不能查看文件内容的变化。
#git diff 查看内容的不同
[root@gitlab-200 /git_date]# git diff a   
# 比对本地工作目录和暂存区文件的不同
[root@gitlab-200 /git_date]# git add a
# 提交a文件到暂存区域、在用git diff是相同的
[root@gitlab-200 /git_date]# git diff ‐‐cached a
# 比对的是暂存区和本地仓库文件的不同处
[root@gitlab-200 /git_date]# git commit ‐m "modified a" 
# 提交后在比对则暂存区和本地仓库内容相同

git commit # 相当于虚拟机的镜像、任何操作都被做了一次快照，可恢复到任意一个位置

[root@gitlab-200 /git_date]# git log 查看历史的git commit快照操作
commit f3a56773c5c08cbffcb4fe331696a2725c03b3c9  # 哈希唯一标识的字符串
Merge: 4c81d52 9ff69f6                   
Author: wufei <wufei008@qq.com>                  # 作者个人信息
Date:   Tue Sep 3 01:10:10 2019 +0800            # 时间

    merge                                        # ‐m 个人写的提交描述信息
[root@gitlab-200 /git_date]# git log --oneline   # 一行简单的显示commit信息
f3a5677 merge
9ff69f6 xxx
4c81d52 xxx
[root@gitlab-200 /git_date]# git log --oneline --decorate # 显示当前的指针指向哪里
f3a5677 (HEAD, tag: v2.0, origin/master, testing, master) merge
9ff69f6 xxx
4c81d52 xxx
[root@gitlab-200 /git_date]# git log ‐p # 显示具体内容的变化
[root@gitlab-200 /git_date]# git log ‐1 # 只显示1条内容

恢复历史数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1.只更改了当前目录
[root@gitlab-200 /git_date]# git checkout ‐‐ a  # 从暂存区覆盖本地工作目录
[root@gitlab-200 /git_date]# git status
2.修改了本地目录且同时提交到 了暂存区
[root@gitlab-200 /git_date]# echo ccc >> a         # 添加新内容
[root@gitlab-200 /git_date]# git add .             #提交到暂存区
[root@gitlab-200 /git_date]# git diff ‐‐cached #比对暂存区和本地仓库的内容
[root@gitlab-200 /git_date]# git reset HEAD a     # 本地仓库覆盖暂存区域
[root@gitlab-200 /git_date]# git diff a
[root@gitlab-200 /git_date]# git diff ‐‐cached a
3.修改了工作目录后提交到了暂存区和本地仓库后进行数据恢复
echo bbb >>a # 提交新的bbb文件到a
git commit ‐m "add bbb"
echo ccc >> a
git commit ‐am "add ccc" # 这时候发现改错代码了，想还原某一次提交的文件快照
[root@gitlab-200 /git_date]# git log ‐‐oneline
[root@gitlab-200 /git_date]# git reset ‐‐hard 4c57a60
#当当前窗口不小心关闭，找不到哈希值
git reflog # 使用git reflog 可查看总历史内容

3.4.4 git分支

分支即是平行空间，假设你在为某个手机系统研发拍照功能，代码已经完成了80%，但如果将这不完整的代码直接提交到git仓库中，又有可能影响到其他人的工作，此时我们便可以在该软件的项目之上创建一个名叫”拍照功能”的分支，这种分支只会属于你自己，而其他人看不到，等代码编写完成后再与原来的项目主分支合并下即可，这样即能保证代码不丢失，又不影响其他人的工作。

一般在实际的项目开发中，我们要尽量保证master分支是非常稳定的，仅用于发布新版本，平时不要随便直接修改里面的数据文件，而工作的时候则可以新建不同的工作分支，等到工作完成后在合并到master分支上面，所以团队的合作分支看起来会像上面图那样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
[root@gitlab-200 /git_date]# git log --oneline --decorate
f3a5677 (HEAD, tag: v2.0, origin/master, testing, master) merge  # 默认分支指向你最后一次的提交 HEAD头、指针
9ff69f6 xxx
4c81d52 xxx
7353a92 Merge branch 'testing'
7363b5e add newfile master.txt
7768c8d add newfile test.txt
061d4cf (tag: v1.0) newfile b.txt

#HEAD 指针指向哪个分支、说明你当前在哪个分支下工作`
git branch testing   # 新建testing分支
git branch -d testing#删除分支
git checkout testing  #切换分支
git checkout -b testing  # 创建并切换到testing分支
[root@gitlab-200 /git_date]# git branch
* master          # *号在哪里就说明当前在哪个分支上入下图所示
  testing
[root@gitlab-200 /git_date]# git log ‐‐oneline ‐‐decorate # 通过命令查看分支指向
[root@gitlab-200 /git_date]# touch test
[root@gitlab-200 /git_date]# git add .
[root@gitlab-200 /git_date]# git commit ‐m "commit test"
[root@gitlab-200 /git_date]# git checkout master    # 切换到master分支后指针指向到了master
touch master
git add .
git commit ‐m "commit master"

合并分支

1
2
3
4
git merge testing    # 在master分支上进行合并testing分支
git log ‐‐oneline ‐‐decorate
#删除分支‐d参数
git branch ‐d testing

3.4.5 git标签使用

1
2
3
4
5
6
7
8
9
#标签也是指向了一次commit提交，是一个里程碑式的标签，回滚打标签直接加标签号，不需要加唯一字符串不好记
git tag ‐a v1.0 ‐m "aaa bbb master tesing version v1.0"  
# ‐a指定标签名字 ‐m 指定说明文字
git tag    #查看标签
git tag ‐a v2.0 dbead4c ‐m "add bbb version v2.0" 
# 指定某一次的提交为标签
git show v1.0              # 查看v1.0的信息 git show 加标签查看
git reset ‐‐hard v2.0      # 直接还原数据到v2.0
git tag ‐d v2.0            # 删除标签 ‐d参数

第4章 github使用

Github顾名思义是一个Git版本库的托管服务，是目前全球最大的软件仓库，拥有上百万的开发者用户，也是软件开发和寻找资源的最佳途径，Github不仅可以托管各种Git版本仓库，还拥有了更美观的Web界面，您的代码文件可以被任何人克隆，使得开发者为开源项贡献代码变得更加容易，当然也可以付费购买私有库，这样高性价比的私有库真的是帮助到了很多团队和企业

  1. 注册用户
  2. 配置ssh‐key
  3. 创建项目
  4. 克隆项目到本地
  5. 推送新代码到github
1
2
3
4
5
6
7
git remote add origin git@github.com:wf3512638/git_data.git   #创建远程仓库
git remote remove origin 删除远程仓库
[root@gitlab-200 /git_data]# git remote   #查看远程仓库
origin
yum update ‐y nss curl libcurl #升级版本
git push ‐u origin master   #推送本地仓库到远程仓库
git pull   #拉取远程仓库最新代码
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 4.Shell 编程总结 http://linuxwf.com/2020/04/15/4-Shell-%E7%BC%96%E7%A8%8B%E6%80%BB%E7%BB%93/ 2020-04-15T03:38:00.000Z 2020-04-15T03:39:27.000Z

Shell 编程总结

第1章 基础知识

1.linux下默认的shell是? 

1
bash

2.shell脚本书写规范?

1.shell脚本存放统一的目录 /server/scripts

2.脚本名字的结尾使用.sh

3.脚本的开头 必须有解释器 #!/bin/bash

4.脚本内有作者信息 脚本信息

1
2
3
4
5
#Date: 20111111
#Author: wufei
#Blog:            #博客
#Descriptsion:    #描述
#Version： 1.0    #版本

5.每段代码块有注释(尽量使用英文)

6.标点符号 (语法尽量一次性书写完毕

7.成对的符号 一次性书写完毕

3.执行脚本的三种方法?

1
2
3
4
5
6
7
8
9
10
#方法1：直接使用解释器执行
[root@backup /server/scripts]# bash hello.sh 
hello world!
#方法2: 全路径方式执行 需要执行权限
# chmod +x hello.sh
[root@backup ~]# . /server/scripts/hello.sh 
hello world!
#方法3 source .执行脚本  子shell中的内容调用到父shell中执行
[root@backup /server/scripts]# source hello.sh 
hello world!

4.变量可分为两类？

变量可分为两类：环境变量（全局变量）和普通变量（局部变量）

全局变量(环境变量) 针对系统所有用户生效

局部变量(普通变量) 针对当前登录用户生效

5.如何显示默认的环境变量**

1.使用echo命令查看单个环境变量。例如： echo $PATH

2.使用env查看所有环境变量。例如： env

3.使用set查看所有本地定义的环境变量。

6.如何设置环境变量与局部变量

1.在/etc/profile文件中添加变量【对所有用户生效(永久的)】，注意：修改文件后要想马上生效还要运行# source /etc/profile不然只能在下次重进此用户时生效。

2.在用户目录下的.bash_profile文件中增加变量【对单一用户生效(永久的)】

3.直接运行export命令定义变量【只对当前shell(BASH)有效(临时的)】

7.定义变量内容，不加引号、单引号、双引号、反引号结果有什么不同？应该怎么用？

不加引号：直接定义变量的内容，一般用于连续的数字、字符串、路径名等

单引号：所见即所得，引号内是什么就输出什么

双引号：输出变量内容时引号的变量及命令会经过解析后再输出内容

反引号：一般用于引用命令，执行的时候命令会被执行，相当于S0，赋值和输出都要用引号将命令引起来

8.以下参数含义

参数含义
$0获取当前执行的shell脚本的文件名，如果包含路径，则包括脚本路径
$n获取当前执行脚本的第n个参数值，参数从$1开始 $9 以后需要加{}
$#获取当前执行的脚本后面接的参数的总个数
$*脚本所有传参的参数，加双引号将所有参数视为一个整体
$@脚本所有传参的参数，加双引号将所有参数视为不通的独立字符串
$?上一个指令的状态返回值（0为成功，非0失败）
$$当前执行脚本的PID进程号
$!上一个在后台工作的进程的PID
$_获取在此之前的命令或脚本的最后一个参数

9.echo参数含义

参数含义
-n不换行输出内容
-e解析转义字符
转义字符
\n换行
\r回车
\t制表符(tab)
\b退格
\v纵向制表符

10.变量传参的三种方式？

1.直接传参

2.赋值传参

3.read传参

11.统计字符串长度？

1
2
3
4
5
6
7
8
9
10
# echo $test
I am oldboy
# echo ${#test}   #变量前加#可以打印变量的长度
11
# echo $test|wc -L  
11
# expr length "$test"
11
# echo $test|awk '{print length}'
11

12.输出字符串长度小于3的单词

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
[root@backup /server/scripts]# cat for.sh 
#!/bin/bash
for i in I am lizhenya teacher I am 18
do
   [ ${#i} -lt 3 ] && echo $i
done
[root@backup /server/scripts]# sh for.sh 
I
am
I
am
18

[root@backup /server/scripts]# echo "I am lizhenya teacher I am 18"|xargs -n1|awk '{if(length<3)print}'
I
am
I
am
18

[root@backup /server/scripts]# echo "I am lizhenya teacher I am 18"|xargs -n1|awk '{for(i=1;i<=NF;i++)if(length<3)print}'
I
am
I
am
18

13.变量子串的删除和替换

1
2
3
4
5
6
7
8
9
#截取从第二个字符之后的内容，不包含第二个字符
[root@backup /server/scripts]# echo $test
I am oldboy
[root@backup /server/scripts]# 
[root@backup /server/scripts]# echo ${test:2}
am oldboy
#从第二个字符开始截取之后的二个字符
[root@backup /server/scripts]# echo ${test:2:2}
am

14.写出下面特殊变量扩展的意义

1
2
3
4
5
6
${oldboy}   #返回变量$oldboy的内容
${#oldboy}   #返回变量$oldboy的内容的字符长度
${url#*.}      #从.开始删除前面的内容输出
${url##*.}   #从.开始删除最后一个.后面的内容输出
${url%.*}   #删除最后一个.后面的内容输出
${url%%.*}     #删除第一个.后面的内容输出

15.常见的Shell算术运算符

算术运算符意义（*表示常用）
+ 、-加（或正号）、减（或负号）*
*、/、%乘法、除法、取余 *
**冥运算 *
++ 、–增加、减少，可前置也可放在变量的结尾 *
！、&&、||非（取反）、相当于and 、相当于or *
< 、<= 、> 、>=比较符号（小于、小于等于、大于、大于等于）
== 、!= 、=比较符号 （相等、不相等、对于字符串=也可表示相当于）*
<< 、>>向左移位、向右移位
~ 、| 、& 、^按位取反、按位异或、按位于、按位或
= 、+=、-= 、*= 、%=赋值运算符，例如 a+=1 相当于 a=a+1 , a-=1 相当于 a=a-1 *

16.常见的运算命令

运算操作符号与运算命令意义
(())用于整数的运算、效率很高
let用于证书运算，类似于(())
expr可用于整数运算，还有其他功能
bcLinux下的计算程序、可用于整数及小数运算
$[]用于整数运算
awkawk既可用于整数运算，也可用于小数运算
declare定义变量值和属性，-i参数可用于定义整形变量，做运算

17.常用的条件表达式

语法意义
test -f file表示如果file文件存在，则为真（0），否则为假（非0）
test -z表示如果字符串长度是为0，则表达式成立
[ -e file ]文件存在则为真
[ -f file ]是否存在并且为普通文件
[ -d file ]是否为目录
[ -r file ]是否可读
[ -w file ]是否可写
[ -x file ]是否可执行

18.数值表达式

[ 整数1 比较符 整数2 ]

在[]以及test 中使用的比较符号在(())和[[]] 中使用的比较符号说明
-eq== 或 =等于
-ne!=不等于
-gt>大于
-ge>=大于等于
-lt<小于
-le<=小于等于

19.循环控制及状态返回值参数

参数含义
exit退出脚本
return退出函数
local局部变量
breadk跳出循环体
continue跳过本次循环，进行下一次循环

第2章 脚本案例

1.查看磁盘/当前使用状态，如果使用率超过80%则把结果输出

1
2
3
4
#!/bin/sh
usedisk=`df -h|awk 'NR==2{print $(NF-1)}'`
[ ${usedisk%\%} -gt 80 ] && echo "send mail 当前使用为$usedisk" || echo "磁盘使用正常,当前使用率为$usedisk"
[ `df -h|awk -F "[ %]+" 'NR==2{print $(NF-1)}'` -gt 5 ] && echo "send mail" || echo "磁盘使用正常"

统计磁盘使用率 如果磁盘使用率大于 5% 则发邮件报警 当前使用率为? 小于5% 则提示磁盘使用正常 当前使用率为?

1
2
3
4
5
6
7
8
[root@backup /server/scripts]# cat disk.sh 
#!/bin/sh
usedisk=`df -h|awk 'NR==2{print $(NF-1)}'`
[ ${usedisk%\%} -gt 80 ] && echo "send mail 当前使用为$usedisk" || echo "磁盘使用正常,当前使用率为$usedisk"
[ `df -h|awk -F "[ %]+" 'NR==2{print $(NF-1)}'` -gt 5 ] && echo "send mail" || echo "磁盘使用正常"
[root@backup /server/scripts]# sh disk.sh 
磁盘使用正常,当前使用率为4%
磁盘使用正常

2.加大文件描述符

1
echo '*                -       nofile          65535'>>/etc/security/limits.conf

3.使用脚本 统计系统的 主机名 IP地址 虚拟平台 版本号 磁盘使用率 内存使用率 外网IP地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@backup /server/scripts]# cat os.sh 
#!/bin/bash
eth0=$(ip a|awk 'BEGIN{FS="[ /]+"}/eth0$/{print $3}')
eth1=$(ip a|awk 'BEGIN{FS="[ /]+"}/eth1$/{print $3}')
net_IP=$(curl -s ifconfig.me)  # 或者 curl icanhazip.com
VMW=$(hostnamectl | awk '/Virtuali/{print $NF}')
version=$(awk '{print $1,$(NF-1)}' /etc/redhat-release)
disk=$(df|awk 'NR==2{print $(NF-1)}')
mem="$(free|awk 'NR==2{print $3/$2*100}')%"
echo "内网IP为：${eth0}"
echo "外网IP为：${eth1}"
echo "公网IP为：${net_IP}"
echo "虚拟平台为：${VMW}"
echo "操作系统为：${version}"
echo "磁盘使用率为：${disk}"
echo "内存使用率为：${mem}"
[root@backup /server/scripts]# sh os.sh 
内网IP为：10.0.1.41
外网IP为：172.16.1.41
公网IP为：113.88.12.225
虚拟平台为：vmware
操作系统为：CentOS 7.4.1708
磁盘使用率为：4%
内存使用率为：10.2867%

4.反向破解 RANDOM 0-32767

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
案例:反向破解 RANDOM 0-32767
d2c74151
a9982990
4462a9fd
b195fe48
5e77d38
[root@backup /server/scripts]# cat RANDOM.sh 
#!/bin/bash
for i in {0..32767}
do
   num1=`echo $i|md5sum|cut -c1-8`
   [ $num1 = "d2c74151" -o $num1 = "a9982990" -o $num1 = "4462a9fd" -o $num1 = "b195fe48" ];
   [ $? = 0 ] && echo "$num1 is $i"
   num2=`echo $i|md5sum|cut -c1-7`
   [ $num2 = "5e77d38" ];[ $? = 0 ] && echo "$num2 is $i"
done
[root@backup /server/scripts]# sh RANDOM.sh 
4462a9fd is 2458
5e77d38 is 2945
d2c74151 is 6420
a9982990 is 13008
b195fe48 is 29193

5.使用if分支 来比较两个数字的大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[root@backup /server/scripts]# cat count.sh 
#!/bin/sh
read -p "please input two number: " num1 num2
if [[ ! "$num1" =~ ^[0-9]+$ || ! "$num2" =~ ^[0-9]+$ ]]
   then
echo "请输入正确的整数"
exit
fi
if [ $num1 -gt $num2 ];then
echo "$num1>$num2"
elif [ $num1 -lt $num2 ];then
echo "$num1<$num2"
else
echo "$num1=$num2"
fi
[root@backup /server/scripts]# sh count.sh 
please input two number: 10 20
10<20

6.随机生成一个随机数1-100 判断生成的随机数和输入的随机数是否相等,如果相等则退出,大了提示大了,小则提示小了,总共猜了多少次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
[root@backup /server/scripts]# cat 1_100.sh 
#!/bin/sh
ran=`echo $((RANDOM%100+1))`
> ran.txt
read -p "请回车开始系统自动猜: " re
i=1
case $re in
y)
while true
do
ra=`echo $((RANDOM%100+1))`
if [ `grep -w $ra ran.txt|wc -l` -eq 1  ];then
continue
fi
if [ $ra -gt $ran ];then
echo "系统猜的数字为 $ra 猜大了"
 echo $ra >> ran.txt
elif [ $ra -lt $ran ];then
   echo "系统猜的数字为 $ra 猜小了"
 echo $ra >> ran.txt
else 
echo "系统猜对了数字为$ra"
echo "总共猜了 $i 次"
exit
fi
let i++
done
;;
*)
echo hehe
esac

7.按照系统版本号的不同 更改默认YUM源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
[root@backup /server/scripts]# cat yum.sh 
#!/bin/sh
. /etc/init.d/functions
os=`cat /etc/redhat-release |awk '{print $4}'`
if [ "$os" = "(Final)" ]
then
os=`cat /etc/redhat-release|awk '{print $3}'`
fi
ping -c 1 -W1 www.baidu.com &>/dev/null
if [ $? -ne 0 ];then
systemctl restart network
action "请检查网络" /bin/false
else

if [ ${os%%.*} -eq 7 ];then
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo &>/dev/null
if [ $? -eq 0 ];then
   action "yum源已更新完成......." /bin/true
else
   action "yum源更新失败,请检查.." /bin/false
exit
fi

elif [ ${os%%.*} -eq 6 ];then
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo &>/dev/null
        if [ $? -eq 0 ];then
   action "yum源已更新完成......." /bin/true
else
   action "yum源更新失败,请检查.." /bin/false
exit
fi
else
echo "请检查你的版本号"
fi
fi
[root@backup /server/scripts]# sh yum.sh 
yum源已更新完成.......                                     [  OK  ]

8.nginx启动脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
[root@backup /server/scripts]# cat nginx_start.sh 
#!/bin/sh
[ -f /etc/init.d/functions ] && . /etc/init.d/functions
te=$1
test(){

if [ $? -eq 0 ];then
action "Nginx $te is" /bin/true
else
action "Nginx $te is" /bin/false
fi

}
case $1 in 
  start)
/usr/sbin/nginx
test
;;
  stop)
/usr/sbin/nginx -s stop
test
;;
 restart)
/usr/sbin/nginx -s stop
sleep 1
/usr/sbin/nginx
test
;;
reload)
/usr/sbin/nginx -s reload
test
;;
status)
echo "WEB端口号: `netstat -tnulp|grep master|grep '\<tcp\>'|awk '{print $4}'`"
        echo "WEB-PID: `ps axu|grep [n]ginx|grep master|awk '{print $2}'`"
;;
     *)
echo "Usage: $0 {start|stop|status|restart|reload}"
esac

9.生活案例: 吃饭

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
[root@backup /server/scripts]# cat eat.sh 
#!/bin/bash
cat<<EOF
1.皇萌鸡
2.酸笋鱼
3.瓦香鸡
4.炒菜
5.酸辣粉
6.炒粉
7.面
8.饺子
9.不吃
EOF
read -p "想吃什么，请按回车键 :" 
ran=`echo $((RANDOM%9+1))`
case $ran in
1)
echo "皇萌鸡"
;;
2)
echo "酸笋鱼"
;;
3)
echo "瓦香鸡"
;;
4)
echo "炒菜"
;;
5)
echo "酸辣粉"
;;
6)
echo "炒粉"
;;
7)
echo "面"
;;
8)
echo "饺子"
;;
9)
echo "不吃"
;;
esac

10.脚本批量创建10个用户，密码统一为123，需要对用户输入是否为数字和输入的名字是否为空做判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
[root@backup /server/scripts]# cat useradd.sh 
#!/bin/sh
read -p "请输入用户名的前缀: " prefix
[ -z $prefix ] && echo "请输入前缀" && exit
read -p "请输入要创建多少个用户: " num
expr 1 + $num &>/dev/null
[ $? -ne 0 ] && echo "请输入整数" && exit
for i in `seq $num`
do
echo $prefix$i
done
read -p "你确定要创建以上用户吗?[y|yse|Y|YES|n|N|NO]" re
for n in `seq $num`
do
user=$prefix$n
case $re in
   y|yes|Y|YES)
  id $user &>/dev/null
 if [ $? -ne 0 ];then
mm=`mkpasswd -l 8`
 useradd $user  && echo $mm|passwd --stdin $user &>/dev/null
 [ $? -eq 0 ]  
#echo -e "$user\t$mm" >> /tmp/useradd.txt
echo -e "用户: $user\t创建成功\t密码是：$mm"
 else
echo "用户已存在"
continue
 fi
;;
n|N|no|NO)
 echo "不创建则退出"
 exit
 ;;
*)
read -p "你确定要创建以上用户吗?[y|yse|Y|YES|n|N|NO]" re
esac
done

11.简单jumpserver脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
[root@backup /server/scripts]# cat jum.sh 
#/bin/bash
menu(){
cat<<EOF 
1)WEB01=10.0.1.7
2)WEB02=10.0.1.8
3)MySQL=10.0.1.51
4)NFS=10.0.1.31
5)BACKUP=10.0.1.41
6)help
EOF
}
menu
trap "echo 不要乱输入,小心爆炸" INT HUP TSTP
while true
do
read -p "请输入需要连接的服务器: " num
case $num in
        1)
         ssh 10.0.1.7
        ;;
        2)
        ssh 10.0.1.8
        ;;
        3)
        ssh 10.0.1.51
        ;;
        4)
        ssh 10.0.1.31
        ;;
        5)
        ssh 10.0.1.41
        ;;
        6|h)
        clear
        menu
        ;;
        woshiyunwei)
        exit
        ;;
        *)
        echo "请输入正确信息！"
esac
done

12.取10位随机小写字母

1
2
3
4
5
6
7
8
9
10
[root@backup /server/scripts]# cat az.sh 
#!/bin/bash
randstr() {
  index=0
  str=""
  for i in {a..z}; do arr[index]=$i; index=`expr ${index} + 1`; done
  for i in {1..10}; do str="$str${arr[$RANDOM%$index]}"; done
   echo $str
}
echo `randstr`

13.Ping10.0.1.0/24网段那些能通

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[root@backup /server/scripts]# cat ping.sh 
#!/bin/bash
for i in `seq 254`
do
   {
   IP=10.0.1.$i
   ping -c 1 -W 1 $IP &>/dev/null
   if [ $? -eq 0 ];then
      echo "10.0.1.$i is OK"
fi 
} &  
done
wait
echo "在线取IP完成..."

14.输入两个整数计算这两个整数的相加，相减，相乘，相除，求余的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/bin/bash
read -p "please input num1: " num1
read -p "please input num2: " num2
expr $num1 + 1 &>/dev/null
RERVAL_A=$?
expr $num2 + 1 &>/dev/null
RERVAL_B=$?
if [ $RERVAL_A -ne 0 -o $RERVAL_B -ne 0 ];then
echo "请输入整数" 
exit
fi
echo "mun1+num2 =$(( num1 + num2 ))"
echo "mun1-num2 =$(( num1 - num2 ))"
echo "mun1*num2 =$(( num1 * num2 ))"
echo "mun1/num2 =$(( num1 / num2 ))"

15.打印下面这句话中字母数小于5的单词 I am lizhenya teacher I am 18

1
2
3
4
5
6
7
#!/bin/bash
for i in I am lizhenya teacher I am 18
do
if [ ${#i} -lt 5 ];then
echo $i
fi
done

16.写个shell，看看你的linux系统中是否有自定义用户（普通用户），若是有，一共有几个？

1
2
3
#!/bin/bash
user=`awk 'NR!=1' /etc/passwd|awk -F: '/\/bin\/bash$/{print $1}'`
echo $user

17.写一个shell脚本来看看你使用最多的命令是哪些，列出你最常用的命令top10

1
2
3
4
5
#!/bin/bash
HISTFILE=~/.bash_history
set -o history
re=`history|awk '{print $2}'|sort|uniq -c|sort -nr|head`
echo -e "最近使用最多的前个命令10是:\n$re"

18.编写一个脚本，计算100以内所有能被3整除数字的和

1
2
3
4
5
6
7
8
9
#!/bin/bash
sum=0
for i in {1..100}
do
if [ $((i % 3)) -eq 0 ];then
sum=$[$sum+$i]
fi
done
echo $sum

19.写一个脚本计算一下Linux系统所有进程占用内存大小的和

1
2
3
4
5
6
7
#!/bin/bash
sum=0
for mem in `ps aux |awk '{print $6}' |grep -v 'RSS'`
do
sum=$[$sum+$mem]
done
echo "The total memory is $sum."

20.打印一个菜单如下，然后用循环加case语句输出用户输入菜单选项的结果
h 显示命令帮助
f 显示登陆信息
d 显示磁盘挂载
m 查看内存使用
u 查看系统负载
q 退出程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#!/bin/bash
nume(){
cat<<EOF
h 显示命令帮助    
f 显示登陆信息 
d 显示磁盘挂载 
m 查看内存使用 
u 查看系统负载 
q 退出程序
EOF
}
nume
while true
do
read -p “please input num”num
case $num in
h)
man
;;
f)
who
;;
d)
df -h
;;
m)
free -h
;;
u)
w
;;
q)
exit
;;
*)
echo “请输入正确编号 ”
esac
done

21.写一个数组脚本统计/var/log/nginx.log里IP访问次数

1
2
3
4
5
6
7
8
9
10
11
awk ‘{print $1} /var/log/nginx.log >ip.txt
#!/bin/bash
declare -A array
while read line
do
let array[$line]++
done<ip.txt
for i in ${!array[*]}
do
echo “nginx 的$i 访问次数为 $i|sort -nr|wc -l”
done

22.统计下面这句话中字母数不大于6的单词（至少两种方式）

1
2
3
4
5
6
7
8
1.echo “I am oldboy teacher welcome to oldboy training class”|xargs -n1|awk ‘if(length<7){print}’
2.#!/bin/bash
for i in I am oldboy teacher welcome to oldboy training class
do
if [ ${#i} -le 6 ];then
echo $i
fi
done

23.使用for循环在/oldboy目录下通过随机小写10个字母加固定字符串oldboy批量创建10个html文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[root@backup /server/scripts]# cat oldboy.sh 
#!/bin/bash
dir=/oldboy
[ ! -d $dir ] && mkdir $dir
for n in `seq 10`
do
randstr() {
index=0
str=""
  for i in {a..z}; do arr[index]=$i; index=`expr ${index} + 1`; done
  for i in {1..10}; do str="$str${arr[$RANDOM%$index]}"; done
   echo $str
}
touch $dir/`randstr`_oldboy.html
if [ $? -eq 0 ];then
echo `randstr`_oldboy.html create successful
fi
done
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 3.if语句和case语句 http://linuxwf.com/2020/04/15/3-if%E8%AF%AD%E5%8F%A5%E5%92%8Ccase%E8%AF%AD%E5%8F%A5/ 2020-04-15T03:34:00.000Z 2020-04-15T03:35:30.000Z

[TOC]

第3课 if语句和case语句

第1章 if条件语句

1.1 单分支结构

第一种语法：

1
2
3
4
if <条件表达式>
   then
     指令
fi

第二种语法：

1
2
3
if <条件表达式>; then
   指令
fi

嵌套语法：

1
2
3
4
5
6
if <条件表达式>
   then
     if <条件表达式>
       then
         指令 
fi

1.2 双分支结构

如果…那么…，否则…

1
2
3
4
5
6
if <条件表达式>
   then
     指令1
else
     指令2
fi
1
2
3
4
5
6
if [ -f "$file"]
   then
     echo 1
else
     echo 2
fi

1.3 多分支结构

1
2
3
4
5
6
7
8
9
if <条件表达式>
   then
     指令1
elif <条件表达式>
   then
     指令2
else
     指令3
fi

注意：

1）多分支elif，每个elif后都有then

2）最后结尾的else后面不带then

第2章 if语句的多种条件表达式语法

2.1 test 条件表达式

1
2
3
4
if test 表达式
   then
     指令
fi

2.2 [] 条件表达式

1
2
3
4
if [ 字符串或算术表达式 ]
   then
     指令
fi

2.3 [[]] 条件表达式

1
2
3
4
if [ 字符串表达式 ]
   then
     指令
fi

2.4 (()) 条件表达式

1
2
3
4
if (( 算术表达式 ))
   then
     指令
fi

2.5 命令表达式

1
2
3
4
if 命令
   then
     指令
fi

2.6 案例

案例1 使用if分支 来比较两个数字的大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[root@backup /server/scripts]# cat count.sh 
#!/bin/sh
read -p "please input two number: " num1 num2
if [[ ! "$num1" =~ ^[0-9]+$ || ! "$num2" =~ ^[0-9]+$ ]]
   then
echo "请输入正确的整数"
exit
fi
if [ $num1 -gt $num2 ];then
echo "$num1>$num2"
elif [ $num1 -lt $num2 ];then
echo "$num1<$num2"
else
echo "$num1=$num2"
fi
[root@backup /server/scripts]# sh count.sh 
please input two number: 10 20
10<20

案例2 随机生成一个随机数1-100 判断生成的随机数和输入的随机数是否相等,如果相等则退出,大了提示大了,小则提示小了,总共猜了多少次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
echo $(($RANDOM%100+1))
[root@backup /server/scripts]# cat ran.sh 
#!/bin/sh
ran=`echo $((RANDOM%100+1))`
i=0
while true
do
let i++
read -p "请输入你猜的数字[1-100]: " num
if [ $num -gt $ran ];then
echo "你猜的数字大了"
elif [ $num -lt $ran ];then
echo "你猜的数字小了"
else
echo "恭喜你猜对了"
echo "总共猜了${i}次"
exit
fi
done

案例3: 按照系统版本号的不同 更改默认YUM源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
[root@backup /server/scripts]# cat yum.sh 
#!/bin/sh
. /etc/init.d/functions
os=`cat /etc/redhat-release |awk '{print $4}'`
if [ "$os" = "(Final)" ]
then
os=`cat /etc/redhat-release|awk '{print $3}'`
fi
ping -c 1 -W1 www.baidu.com &>/dev/null
if [ $? -ne 0 ];then
systemctl restart network
action "请检查网络" /bin/false
else

if [ ${os%%.*} -eq 7 ];then
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo &>/dev/null
if [ $? -eq 0 ];then
   action "yum源已更新完成......." /bin/true
else
   action "yum源更新失败,请检查.." /bin/false
exit
fi

elif [ ${os%%.*} -eq 6 ];then
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo &>/dev/null
        if [ $? -eq 0 ];then
   action "yum源已更新完成......." /bin/true
else
   action "yum源更新失败,请检查.." /bin/false
exit
fi
else
echo "请检查你的版本号"
fi
fi
[root@backup /server/scripts]# sh yum.sh 
yum源已更新完成.......                                     [  OK  ]

第3章 比较大小案例

1
2
3
4
5
6
7
8
9
10
11
12
13
if [ $# -ne 2 ];then              #判断传参个数
   echo "USAGE:$0 arg1 arg2"      #传参个数不符合要求，则打印提示后退出
   exit 2
fi

expr $a + 1 &>/dev/null           #判断变量a是否为整数
RETVAL1=$?                        #获取expr命令返回值并赋值给RETVAL1
expr $b + 1 &>/dev/null           #判断变量b是否为整数
RETVAL2=$?                        #获取expr命令返回值并赋值给RETVAL2
if [ RETVAL1 -ne 0 -a RETVAL2 -ne 0 ];then  #判断前后均为整数
   echo "please input two int again"
   exit 3
fi

第4章 菜单的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/bin/sh
echo -e "\t\t\t1 PHP5.5"
echo -e "\t\t\t2 PHP5.7"
echo -e "\t\t\t3 PHP7.1"
echo -e "\t\t\t4 PHP7.2"
cat<<EOF
* * * * * * * * * * * * *
*1. MySQL*
*2. redis*
*3. PHP*
*4. iptables*
*5. zabbix       *
* * * * * * * * * * * * *
EOF

第5章 Shell函数

5.1 函数介绍

使用shell函数的优势：

1.把相同的程序段定义为函数，可减少整个程序的代码量，提示开发效率

2.增加程序的可读性、易读性，提升管理效率

1
2
3
4
function 函数名(){
    指令
    return n
}

shell函数的执行

1.执行shell函数时，函数名前的function 和函数后的小括号都不带

2.函数的定义必须要在执行的程序前加定义或加载

3.shell执行系统中各种程序的执行顺序，系统别名-函数-系统命令-可执行文件

4.函数执行时，会调用他的脚本公用变量，也可以为函数设置局部变量及特殊位置参数

5.在shell函数中，return 命令和exit相似，return的作用时退出函数，二exit时推出脚本

6.return语句会返回一个退出值给调用函数的房钱程序，而exit会返回一个退出值给当前shell

7.如果要将函数存放在独立的文件中，被脚本加载使用时，需要使用source 或 “.”

8.在函数中一般使用local定义局部变量 ，这些变量离开函数后会消失

5.2 函数实践

1
2
3
4
5
6
7
8
9
10
#!/bin/bash
#定义两个函数，名字为oldboy和oldgirl
oldboy(){
    echo "I am oldboy"
}
function oldgirl(){
    echo "I am oldgirl"
}
oldboy   #调用函数
oldgirl  #调用函数

第6章 case条件语句

case语法

1
2
3
4
5
6
7
8
9
10
11
12
13
case 变量 in
变量内容1)
命令组
;;
变量内容2)
命令组
;;
变量内容3)
命令组
;;
*)
echo "请输入正确的变量"
esac
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@backup /server/scripts]# cat case.sh 
#!/bin/bash
read -p "please input [shell|MySQL|kvm]: " name
case $name in
shell)
     echo "shell...."
             ;;
MySQL)
     echo "mysql hehe ......"
             ;;
kvm)
    echo "kvm hehe ......"
    ;;
*)
           echo "请输入正确参数： "
esac

case案例: 使用case开发一个启动脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
[root@backup /server/scripts]# cat nginx_start.sh 
#!/bin/sh
[ -f /etc/init.d/functions ] && . /etc/init.d/functions
te=$1
test(){

if [ $? -eq 0 ];then
action "Nginx $te is" /bin/true
else
action "Nginx $te is" /bin/false
fi

}
case $1 in 
  start)
/usr/sbin/nginx
test
;;
  stop)
/usr/sbin/nginx -s stop
test
;;
 restart)
/usr/sbin/nginx -s stop
sleep 1
/usr/sbin/nginx
test
;;
reload)
/usr/sbin/nginx -s reload
test
;;
status)
echo "WEB端口号: `netstat -tnulp|grep master|grep '\<tcp\>'|awk '{print $4}'`"
        echo "WEB-PID: `ps axu|grep [n]ginx|grep master|awk '{print $2}'`"
;;
     *)
echo "Usage: $0 {start|stop|status|restart|reload}"
esac

生活案例: 吃饭

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
[root@backup /server/scripts]# cat eat.sh 
#!/bin/bash
cat<<EOF
1.皇萌鸡
2.酸笋鱼
3.瓦香鸡
4.炒菜
5.酸辣粉
6.炒粉
7.面
8.饺子
9.不吃
EOF
read -p "想吃什么，请按回车键 :" 
ran=`echo $((RANDOM%9+1))`
case $ran in
1)
echo "皇萌鸡"
;;
2)
echo "酸笋鱼"
;;
3)
echo "瓦香鸡"
;;
4)
echo "炒菜"
;;
5)
echo "酸辣粉"
;;
6)
echo "炒粉"
;;
7)
echo "面"
;;
8)
echo "饺子"
;;
9)
echo "不吃"
;;
esac
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 2.Shell脚本的条件测试与比较 http://linuxwf.com/2020/04/15/2-Shell%E8%84%9A%E6%9C%AC%E7%9A%84%E6%9D%A1%E4%BB%B6%E6%B5%8B%E8%AF%95%E4%B8%8E%E6%AF%94%E8%BE%83/ 2020-04-15T03:17:00.000Z 2020-04-15T03:18:04.000Z

Shell条件表达式与整数比较

第1章 常用的条件表达式

语法意义
test -f file表示如果file文件存在，则为真（0），否则为假（非0）
test -z表示如果字符串长度是为0，则表达式成立
[ -e file ]文件存在则为真
[ -f file ]是否存在并且为普通文件
[ -d file ]是否为目录
[ -r file ]是否可读
[ -w file ]是否可写
[ -x file ]是否可执行

1.1 test

1
2
#如果file文件存在，则输出true,否则则输出false
test -f file && echo true || echo false

用test -z 来测试字符段长度是否为0

1
2
[root@backup ~]# test -z "oldboy" && echo 1||echo 0
0

1.2 []

1
2
3
4
5
6
7
8
9
10
11
12
[root@backup ~]# [ -e /etc ] && echo "文件存在"||echo "文件不存在"
文件存在
[root@backup ~]# [ -e /etc/hosts ] && echo "文件存在"||echo "文件不存在"
文件存在
[root@backup ~]# [ -e /etcccc ] && echo "文件存在"||echo "文件不存在"
文件不存在
[root@backup ~]# [ -f /etcccc ] && echo "文件存在"||echo "文件不存在"
文件不存在
[root@backup ~]# [ -f /etc ] && echo "文件存在"||echo "文件不存在"
文件不存在
[root@backup ~]# [ -f /etc/passwd ] && echo "文件存在"||echo "文件不存在"
文件存在

案例:

1
# [ -f /etc/init.d/functions ] && source /etc/init.d/functions
1
2
3
4
5
6
7
8
9
10
11
12
13
[root@backup ~]# [ -d /etc/passwd ] && echo "文件存在"||echo "文件不存在"
文件不存在
[root@backup ~]# [ -d /etc/ ] && echo "文件存在"||echo "文件不存在"
文件存在
[root@backup ~]# [ ! -d /etc/ ] && echo "文件存在"||echo "文件不存在"
文件不存在
[root@backup ~]# [ -d /etc/ ] && echo "文件存在"||echo "文件不存在"
文件存在
[root@backup ~]# [ -d /etcc ] && echo "文件存在"||echo "文件不存在"
文件不存在
[root@backup ~]# [ ! -d /etccc ] && mkdir /etccc
[root@backup ~]# [ -x /etc/shadow ] && echo "可读" || echo "不可读"
不可读

案例: 如果目录不存在则创建

1
2
3
[root@backup ~]# [ -d /etcc ] || mkdir /etcc
[root@backup ~]# ll /etcc
total 0

1.3 [[]] 正则

[[]]与[]的区别：

[[]]中可以使用通配符进行匹配

1
# [[ -f /tmp/oldboy.txt ]] && echo 1 || echo 0

第2章 数值表达式

整数比较

[ 整数1 比较符 整数2 ]

在[]以及test 中使用的比较符号在(())和[[]] 中使用的比较符号说明
-eq== 或 =等于
-ne!=不等于
-gt>大于
-ge>=大于等于
-lt<小于
-le<=小于等于

2.1 []

具体实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
[root@backup ~]# [ 10 -eq 10 ] && echo "成立" || echo "不成立"
成立
[root@backup ~]# [ 10 -gt 10 ] && echo "成立" || echo "不成立"
不成立
[root@backup ~]# [ 10 -ge 10 ] && echo "成立" || echo "不成立"
成立
[root@backup ~]# [ 10 -le 10 ] && echo "成立" || echo "不成立"
成立
[root@backup ~]# [ 11 -le 10 ] && echo "成立" || echo "不成立"
不成立
[root@backup ~]# [ 11 -ne 10 ] && echo "成立" || echo "不成立"
成立
[root@backup ~]# [ 11 -gt 10 ] && echo "成立" || echo "不成立"
成立
[root@backup ~]# [ 11 -gt 100 ] && echo "成立" || echo "不成立"
不成立
[root@backup ~]# [ 11 -lt 100 ] && echo "成立" || echo "不成立"
成立
[root@backup ~]# [ 11 -ne 100 ] && echo "成立" || echo "不成立"
成立

2.2 (()) [[]]

1
2
3
4
5
6
=或==
>
>=
<
<=
1=

案例: 统计磁盘使用率 如果磁盘使用率大于 5% 则发邮件报警 当前使用率为? 小于5% 则提示磁盘使用正常 当前使用率为?

1
2
3
4
5
6
7
8
[root@backup /server/scripts]# cat disk.sh 
#!/bin/sh
usedisk=`df -h|awk 'NR==2{print $(NF-1)}'`
[ ${usedisk%\%} -gt 80 ] && echo "send mail 当前使用为$usedisk" || echo "磁盘使用正常,当前使用率为$usedisk"
[ `df -h|awk -F "[ %]+" 'NR==2{print $(NF-1)}'` -gt 5 ] && echo "send mail" || echo "磁盘使用正常"
[root@backup /server/scripts]# sh disk.sh 
磁盘使用正常,当前使用率为4%
磁盘使用正常

案例2: 统计内存使用率 如果大于5% 发邮件 小于5 提示正常

  1. 如何查看使用率 并取出数值 计算百分比 使用/总的*100
  2. 如何做比较 [ ]
  3. 如何输出内容
  4. 测试
1
2
[root@backup /server/scripts]# [ `free|awk 'NR==2{print $3/$2*100}'|awk -F. '{print $1}'` -gt 11 ] && echo "send mail"|| echo ok
ok

案例3: 统计系统负载 负载超过2则发邮件 小于1则正常

1
2
3
4
ab -n 500000 -c 20000 http://127.0.0.1/index.html
加大文件描述符
echo '*                -       nofile          65535'>>/etc/security/limits.conf
重新打开窗口

案例4：使用脚本 统计系统的 主机名 IP地址 虚拟平台 版本号 磁盘使用率 内存使用率 外网IP地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@backup /server/scripts]# cat os.sh 
#!/bin/bash
eth0=$(ip a|awk 'BEGIN{FS="[ /]+"}/eth0$/{print $3}')
eth1=$(ip a|awk 'BEGIN{FS="[ /]+"}/eth1$/{print $3}')
net_IP=$(curl -s ifconfig.me)  # 或者 curl icanhazip.com
VMW=$(hostnamectl | awk '/Virtuali/{print $NF}')
version=$(awk '{print $1,$(NF-1)}' /etc/redhat-release)
disk=$(df|awk 'NR==2{print $(NF-1)}')
mem="$(free|awk 'NR==2{print $3/$2*100}')%"
echo "内网IP为：${eth0}"
echo "外网IP为：${eth1}"
echo "公网IP为：${net_IP}"
echo "虚拟平台为：${VMW}"
echo "操作系统为：${version}"
echo "磁盘使用率为：${disk}"
echo "内存使用率为：${mem}"
[root@backup /server/scripts]# sh os.sh 
内网IP为：10.0.1.41
外网IP为：172.16.1.41
公网IP为：113.88.12.225
虚拟平台为：vmware
操作系统为：CentOS 7.4.1708
磁盘使用率为：4%
内存使用率为：10.2867%

第3章 多整数比较

在[] 和 test 中使用的符号在[[]] 和 (()) 中使用的符号说明
-a&&and 与，两端都为真，则结果为真
-o||or 或，两端有一个为真，则为真
!!not 非，两端相反为真，则结果为真
1
2
[ 整数1 比较符 整数2 -o 整数3 比较符 整数4 ]
[ 整数1 比较符 整数2 -a 整数3 比较符 整数4 ]
1
2
3
4
5
6
[root@backup ~]# [ 10 -eq 10 -o 100 -ne 100 ]
[root@backup ~]# echo $?
0
[root@backup ~]# [ 10 -eq 10 -a 100 -ne 100 ]
[root@backup ~]# echo $?
1

案例:反向破解 RANDOM 0-32767

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
案例:反向破解 RANDOM 0-32767
d2c74151
a9982990
4462a9fd
b195fe48
5e77d38
[root@backup /server/scripts]# cat RANDOM.sh 
#!/bin/bash
for i in {0..32767}
do
   num1=`echo $i|md5sum|cut -c1-8`
   [ $num1 = "d2c74151" -o $num1 = "a9982990" -o $num1 = "4462a9fd" -o $num1 = "b195fe48" ];
   [ $? = 0 ] && echo "$num1 is $i"
   num2=`echo $i|md5sum|cut -c1-7`
   [ $num2 = "5e77d38" ];[ $? = 0 ] && echo "$num2 is $i"
done
[root@backup /server/scripts]# sh RANDOM.sh 
4462a9fd is 2458
5e77d38 is 2945
d2c74151 is 6420
a9982990 is 13008
b195fe48 is 29193

第4章 字符串比较

字符串比较 必须加双引号

1
2
3
[root@backup ~]# [ "$USER" = root ]
[root@backup ~]# echo $?
0

-z 值为0 则为真
-n 值不为0 则为真

1
2
3
4
5
6
7
8
9
10
11
[root@backup ~]# echo $?
0
[root@backup ~]# name=alex
[root@backup ~]# echo $name
alex
[root@backup ~]# [ -z $name ]
[root@backup ~]# echo $?
1
[root@backup ~]# [ -n $name ]
[root@backup ~]# echo $?
0

案例: 判断传参是否为空

1
2


第5章 正则比对

正则比对 [[]]
取反 ! 写在表达式的前面

1
2
3
4
5
6
7
8
[root@backup /server/scripts]# [ "$USER" =~ ^r ]
-bash: [: =~: binary operator expected
[root@backup /server/scripts]# [[ "$USER" =~ ^r ]]   #必须[[]]
[root@backup /server/scripts]# echo $?
0
[root@backup /server/scripts]# [[ ! "$USER" =~ ^n ]]   #取反卸载最前面
[root@backup /server/scripts]# echo $?
0

判断数字是否为整数

1
[[ "$num" =~ ^[0-9]+$ ]]

案例: 使用read 传参方式 传入两个数字 做比较 大了则提示大了 小了则提示小了 等于则等于=
禁止使用if

1
2


]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 1.shell编程介绍及变量 http://linuxwf.com/2020/04/15/1-shell%E7%BC%96%E7%A8%8B%E4%BB%8B%E7%BB%8D%E5%8F%8A%E5%8F%98%E9%87%8F/ 2020-04-15T03:13:00.000Z 2020-04-15T03:14:33.000Z

shell编程介绍及变量

第1章 如何学好shell编程

1.1 为什么学习shell编程

shell编程在工作中做什么?

shell脚本语言是实现Linux系统管理及自动化运维必须的重要工具。

  1. 安装操作系统(手动安全ISO) 自动化安装(kickstart cobbler)shell脚本

  2. 初始化操作系统 优化(SSH优化 关闭SElinux 优化防火墙 c6.x iptables C7.xfirewalld NTP时间同步 更改默认YUM源 字符集 安装常用的软件 lrzsz net-tools tree.. wget 隐藏版本信息 加大文件描述符 内核优化…)
    初始化写入脚本 自动化执行

  3. 安装服务(Nginx PHP MySQL MariaDB NFS sersync REDIS keepalived docker….zabbix shell 脚本自动选择安装)

  4. 配置文件(优化)

  5. 启动—-停止(centos6.x /etc/init.d/server start centos7 systemctl start server) 系统默认的启动方式 shell脚本
    py写的程序 jumpserver
    python3.5 test.py 传参 –redis 10.0.0.22 –prot 6379 –IPlog – – –
    python3.5 test.py -h
    放入shell脚本命名 log_count.start
    停止py服务 log_count.stop ps axu|grep test.py|grep -v grep|awk ‘{print $2}’|xargs kill -9

  6. 监控 zabbix cacti(流程) nagios ELK (公司研发监控平台)
    监控的值(shell脚本统计)

  7. 日志统计 三剑客 日志切割(脚本+定时任务)

1.2 学习shell编程所需基础知识

学好shell编程并通过shell脚本轻松实现自动化管理企业生产系统必备基础如下：

  1. 熟练使用vim编辑器，熟悉SSH终端及“vimrc”等的配置。

  2. 掌握一定Linux命令基础，至少80个，熟练使用。

  3. 熟练掌握Linux正则表达式及三剑客（grep、sed、awk）

  4. 熟悉常见的Linux网络服务器部署、优化、日志分析和排错

1.3 如何才能学好shell

  1. 掌握Shell基本语法

  2. 掌握常见语法 环境变量—数值比较–条件表达式—if判断—for循环–while循环–case语句–函数–数组—条件控制语句 exit continue break

  3. 修改脚本内容(完善脚本)形成自己的开发风格

  4. 套用 框架(公司中大部分脚本的写法) 熟能生巧，从简单坐骑，简单判断、简单循环

  5. 多模仿、多思考

  6. 学会分析问题，形成编程思维

  7. 编程名字要规范、采用驼峰语法

  8. 不要拿来主义，特别是新手

第2章 shell脚本入门

2.1 什么是shell?

shell 是一个命令解释器

shell存在于操作系统最外层，负责与用户直接对话，对用户的输入解析给操作系统，并处理各种各样的输出结果，然后输出到屏幕返回给用户。

面试题: linux下默认的shell是? bash

命令解释器 pwd ls

bash? 当前的命令行 和shell脚本 文本内有可执行命令 bash

当前的bash 父shell 文本内的命令 子shell

子shell可继承父shell的变量 父shell无法继续子shell的变量

交互式shell shll等待输入 输入命令 shell执行并返回结果 交互式

非交互式 把可执行命令 放入文本中 定时任务执行 称为非交互式

2.2 什么是shell脚本

shell脚本：当命令或程序语句不在命令行下执行，而是通过一个程序文件来执行时，该程序被称为shell脚本。

命令的大礼包 把可执行命令放到文件中 称为shell脚本(判断语句 循环语句 数组….)

2.3 shell脚本语言的种类

1.Bourne shell

2.C shell

常用的脚本语言：

PHP Perl Python Shell

Shell脚本语言 优势在于处理偏系统底层的业务，如：一键自动化、优化、监控报警、软件启动、日志分析等脚本。shell更符合Linux运维简单、易用、高效的三大基本原则。

2.4 Shell的书写规范

1) shell脚本存放统一的目录 /server/scripts

2) 脚本名字的结尾使用.sh

3) 脚本的开头 必须有解释器 #!/bin/bash

4) 脚本内有作者信息 脚本信息

1
2
3
4
5
#Date: 20111111
#Author: wufei
#Blog:            #博客
#Descriptsion:    #描述
#Version： 1.0    #版本

5) 每段代码块有注释(尽量使用英文)

6) 标点符号 (语法尽量一次性书写完毕

7) 成对的符号 一次性书写完毕

2.5 第1个Shell脚本

1
2
3
[root@backup /server/scripts]# cat hello.sh 
#!bin/bash
echo "hello world!"

执行脚本的三种方法：

1
2
3
4
5
6
7
8
9
10
#方法1：直接使用解释器执行
[root@backup /server/scripts]# bash hello.sh 
hello world!
#方法2: 全路径方式执行 需要执行权限
# chmod +x hello.sh
[root@backup ~]# . /server/scripts/hello.sh 
hello world!
#方法3 source .执行脚本  子shell中的内容调用到父shell中执行
[root@backup /server/scripts]# source hello.sh 
hello world!
1
2
3
4
if 条件内容
   then
     内容
fi

一次性完成for循环语句格式

1
2
3
4
for
do
    内容
done

第3章 Shell变量

3.1 什么是变量？

1
2
3
4
5
[root@backup /server/scripts]# echo $LANG
en_US.UTF-8
[root@backup /server/scripts]# oldboy="i am oldboy"
[root@backup /server/scripts]# echo $oldboy
i am oldboy

3.2 变量类型：

变量可分为两类：环境变量（全局变量）和普通变量（局部变量）

全局变量(环境变量) 针对系统所有用户生效
局部变量(普通变量) 针对当前登录用户生效

变量生存周期分类 两类
临时性 export 声明变量即可 或者 name=oldboy
永久性 修改配置文件 /etc/profile

1
2
3
4
5
6
7
8
9
10
环境变量文件执行顺序
1. /etc/profile
2. .bash_profile
3. .bashrc
4. /etc/bashrc
如果按照文件内容的生效顺序
1. /etc/profile
2. .bashrc
3. /etc/bashrc
4. .bash_profile

3.3 如何定义变量

要求以字母 数字 和下划线组合 只能以字母和_开头 等号两端不允许有空格 名字 见名直其意

1
2
3
4
5
变量名字的定义的语法:
OLDBOY_AGE=18  系统用的变量都是大写
oldboy_age=18  全小写
oldboy_Age=18  小驼峰语法
Oldboy_Age=18  大驼峰语法

普通变量定义：

1
2
3
变量名=value           #赋值时不加引号
变量名='value'         #赋值时加单引号
变量名=“value“         #赋值时加双引号

变量值得定义:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1.数字定义  连续的数字    oldboy=188888
2.字符串定义 连续的字符串 name="oldboy alex lidao" 不知道加什么就加双引号
  例子: CODE_DIR=/etc/sysconfig/network-scripts/
name='$oldboy'  所见即所得 不解析变量
[root@backup ~]# name=oldboy
[root@backup ~]# echo "$name"
oldboy
[root@backup ~]# echo '$name'
$name
3.命令的定义
  方法1  time=`date +%F`
  方法2  time=$(date +%F)
[root@backup /server/scripts]# time=`date +%F-%H-%M-%S`
[root@backup /server/scripts]# echo $time
2019-08-22-22-02-18
[root@backup /server/scripts]# echo $time   #第二次运行还是一样
2019-08-22-22-02-18
[root@backup /server/scripts]# time=`date +%F-%H-%M-%S`   #重新再次赋值
[root@backup /server/scripts]# echo $time                 #重新赋值后结果不同
2019-08-22-22-02-28

第4章 特殊的位置参数变量

位置变量作用说明
$0获取当前执行的shell脚本的文件名，如果包含路径，则包括脚本路径
$n获取当前执行脚本的第n个参数值，参数从$1开始 $9 以后需要加{}
$#获取当前执行的脚本后面接的参数的总个数
$*获取当前执行脚本所有传参的参数，不加引号和$@相同
$@获取脚本的所有的参数 不加双引号和$* 相同 加上双引号则把参数视为独立的(在循环体中)

4.1 设置15个参数，用于传递

1
2
3
4
5
6
7
8
9
10
11
12
[root@backup /server/scripts]# cat n.sh 
#!/bin/bash
echo $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15
[root@backup /server/scripts]# sh n.sh {a..z}
a b c d e f g h i a0 a1 a2 a3 a4 a5

#当位置参数数字>9时，需要用{}将数字括起来，才能正常显示
[root@backup /server/scripts]# cat n.sh 
#!/bin/bash
echo $1 $2 $3 $4 $5 $6 $7 $8 $9 ${10} ${11} ${12} ${13} ${14} ${15}
[root@backup /server/scripts]# sh n.sh {a..z}
a b c d e f g h i j k l m n o

4.2 特殊变量$0

获取脚本名称及路径

1
2
3
4
5
6
7
8
9
10
[root@backup /server/scripts]# cat n.sh
echo $0
[root@backup /server/scripts]# sh n.sh
n.sh
[root@backup ~]# sh /server/scripts/n.sh 
/server/scripts/n.sh
[root@backup /server/scripts]# dirname /server/scripts/n.sh  #dirname只获取路径
/server/scripts
[root@backup /server/scripts]# basename /server/scripts/n.sh 
n.sh                                                       #basename只获取脚本名称

4.3 特殊变量$#

通过$#获取脚本传参的总个数

1
2
3
4
5
6
[root@backup /server/scripts]# cat n.sh 
echo $1 $2 $3 $4 $5 $6 $7 $8 $9
echo $#
[root@backup /server/scripts]# sh n.sh {a..z}
a b c d e f g h i
26

案例一

1
2
3
4
5
6
[root@backup /server/scripts]# [ $# -eq 2 ] || echo "请重新输入两个参数"
请重新输入两个参数
[root@backup /server/scripts]# [ 3 -ne 2 ] && echo ok|| echo error
ok
[root@backup /server/scripts]# [ 2 -ne 2 ] && echo ok|| echo error
error

案例二

1
2
3
4
5
6
7
8
9
10
11
12
[root@backup /server/scripts]# cat n.sh 
#!/bin/bash
if [ $# -ne 2 ]
   then 
    echo "USAGE:/bin/bash -bash arg1 arg2"
   exit 1
fi
echo $1 $2
[root@backup /server/scripts]# sh n.sh 
USAGE:/bin/bash -bash arg1 arg2
[root@backup /server/scripts]# sh n.sh oldboy 123456
oldboy 123456

4.4 特殊变量$*和$@

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[root@backup /server/scripts]# set -- "I am" oldboy teacher
[root@backup /server/scripts]# echo $*
I am oldboy teacher
[root@backup /server/scripts]# echo $@
I am oldboy teacher
#在循环中先对比不带“”时，2者无区别
[root@backup /server/scripts]# for i in $*;do echo $i;done
I
am
oldboy
teacher
[root@backup /server/scripts]# for i in $@;do echo $i;done
I
am
oldboy
teacher
#在循环中带“”时，2者的区别
[root@backup /server/scripts]# for i in "$*";do echo $i;done
I am oldboy teacher
[root@backup /server/scripts]# for i in "$@";do echo $i;done
I am
oldboy
teacher

第5章 特殊的位置状态变量

位置变量作用说明
$?获取上一个指令的执行状态并返回值（0为成功，非0为失败）
$$获取当前执行的shell脚本的进程号（pid），脚本名字相同时使用
$!获取上一个后台工作的进程的进程号（pid） ，调试脚本时使用
$_获取在此之前执行的命令或脚本的最后一个参数 ，相当于ESE.

5.1 特殊变量$0使用

判断上一个命令是否执行成功,可用于判断服务是否正确执行或命令是否执行成功

当备份数据时，可通过$?来判断是否成功，备份数据是否完整

1
2
3
4
5
6
7
8
[root@backup /server/scripts]# pwd
/server/scripts
[root@backup /server/scripts]# echo $?
0
[root@backup /server/scripts]# lll
-bash: lll: command not found
[root@backup /server/scripts]# echo $?
127

5.2 特殊变量$$使用

获取脚本执行的进程号pid

1
2
3
4
5
6
7
8
9
10
[root@backup /server/scripts]# cat test.sh 
#!/bin/bash
echo $$ > /tmp/test.pid
sleep 300
[root@backup /server/scripts]# sh test.sh 
[root@backup ~]# ps -ef |grep test.sh
root       5641   4909  0 09:51 pts/1    00:00:00 sh test.sh
root       5667   5643  0 09:51 pts/2    00:00:00 grep --color=auto test.sh
[root@backup ~]# cat /tmp/test.pid 
5641

5.3 特殊变量$_使用

获取上一条命令的最后一个参数

1
2
3
[root@backup ~]# cd /server/scripts/
[root@backup /server/scripts]# echo $_
/server/scripts/

5.4 特殊变量$!使用

用于获取上一次执行脚本的pid

第6章 变量传参的三种方法

6.1 直接传参

1
2
[root@backup /server/scripts]# sh n.sh oldboy 123456
oldboy 123456

6.2 赋值传参

1
2
3
4
5
6
7
8
[root@backup /server/scripts]# cat ping.sh 
#!/bin/bash
#方法2
url=$1
ping -c 1  $url &>/dev/null
[ $? -eq 0 ] && echo "ping $url is ok" || echo "ping $url is error"
[root@backup /server/scripts]# sh ping.sh www.qq.com
ping www.qq.com is ok

6.3 read传参

1
2
3
4
5
6
7
8
9
10
11
12
[root@backup /server/scripts]# cat ping.sh 
#!/bin/bash
#方法3
read -p "please input url is: " url
ping -c 1  $url &>/dev/null
[ $? -eq 0 ] && echo "ping $url is ok" || echo "ping $url is error"
[root@backup /server/scripts]# sh ping.sh
please input url is: www.qq.com
ping www.qq.com is ok
[root@backup /server/scripts]# sh ping.sh 
please input url is: www.qqq.com
ping www.qqq.com is error

6.4 案例 使用三种传参方式 做ping url

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[root@backup /server/scripts]# cat ping.sh 
#!/bin/bash
#方法1
ping -c 1  $1 &>/dev/null
[ $? -eq 0 ] && echo "ping $1 is ok" || echo "ping $1 is error"
#方法2
url=$1
ping -c 1  $url &>/dev/null
[ $? -eq 0 ] && echo "ping $url is ok" || echo "ping $url is error"
#方法3
read -p "please input url is: " url
ping -c 1  $url &>/dev/null
[ $? -eq 0 ] && echo "ping $url is ok" || echo "ping $url is error"
[root@backup /server/scripts]# sh ping.sh www.qq.com
ping www.qq.com is ok
ping www.qq.com is ok
please input url is: www.qq.com
ping www.qq.com is ok

第7章 变量的子串(常用)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[root@backup /server/scripts]# test="I am oldboy"
[root@backup /server/scripts]# echo $test
I am oldboy
[root@backup /server/scripts]# echo ${#test}   #变量前加#可以打印变量的长度
11
[root@backup /server/scripts]# echo $test|wc -L  
11
[root@backup /server/scripts]# expr length "$test"
11
[root@backup /server/scripts]# echo ${test}|awk '{print $2}'
am
[root@backup /server/scripts]# echo ${test}|cut -c3-4
am
[root@backup /server/scripts]# echo ${test}|grep -o am
am
[root@backup /server/scripts]# echo ${test:2:2}
am

面试题: 统计字符串长度

1
2
3
4
5
6
7
8
9
10
# echo $test
I am oldboy
# echo ${#test}   #变量前加#可以打印变量的长度
11
# echo $test|wc -L  
11
# expr length "$test"
11
# echo $test|awk '{print length}'
11

面试题2: 输出字符串长度小于3的单词

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
[root@backup /server/scripts]# cat for.sh 
#!/bin/bash
for i in I am lizhenya teacher I am 18
do
   [ ${#i} -lt 3 ] && echo $i
done
[root@backup /server/scripts]# sh for.sh 
I
am
I
am
18

[root@backup /server/scripts]# echo "I am lizhenya teacher I am 18"|xargs -n1|awk '{if(length<3)print}'
I
am
I
am
18

[root@backup /server/scripts]# echo "I am lizhenya teacher I am 18"|xargs -n1|awk '{for(i=1;i<=NF;i++)if(length<3)print}'
I
am
I
am
18

变量子串的删除和替换

1
2
3
4
5
6
7
8
9
#截取从第二个字符之后的内容，不包含第二个字符
[root@backup /server/scripts]# echo $test
I am oldboy
[root@backup /server/scripts]# 
[root@backup /server/scripts]# echo ${test:2}
am oldboy
#从第二个字符开始截取之后的二个字符
[root@backup /server/scripts]# echo ${test:2:2}
am

#从前面往后删除 ## 贪婪匹配

%从后往前删除

// 替换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

[root@backup /server/scripts]# url=www.baidu.com
[root@backup /server/scripts]# echo ${url#*.}    #从.开始删除前面的内容输出
baidu.com
[root@backup /server/scripts]# echo ${url#*.*.}  #从第二个.开始删除前面的内容输出
com
[root@backup /server/scripts]# echo ${url##*.}   #贪婪匹配
com

[root@backup /server/scripts]# echo ${url%.*}
www.baidu
[root@backup /server/scripts]# echo ${url%.*.*}
www
[root@backup /server/scripts]# echo ${url%%.*}   #贪婪匹配
www

#url// 替换
[root@backup /server/scripts]# echo $url
www.baidu.com
[root@backup /server/scripts]# echo ${url/baidu/qq}
www.qq.com
[root@backup /server/scripts]# echo ${url/w/S}
Sww.baidu.com
[root@backup /server/scripts]# echo ${url//w/S}
SSS.baidu.com

第8章 变量的数值计算

常见的Shell算术运算符

算术运算符意义（*表示常用）
+ 、-加（或正号）、减（或负号）*
*、/、%乘法、除法、取余 *
**冥运算 *
++ 、–增加、减少，可前置也可放在变量的结尾 *
！、&&、||非（取反）、相当于and 、相当于or *
< 、<= 、> 、>=比较符号（小于、小于等于、大于、大于等于）
== 、!= 、=比较符号 （相等、不相等、对于字符串=也可表示相当于）*
<< 、>>向左移位、向右移位
~ 、| 、& 、^按位取反、按位异或、按位于、按位或
= 、+=、-= 、*= 、%=赋值运算符，例如 a+=1 相当于 a=a+1 , a-=1 相当于 a=a-1 *

常见的运算命令

运算操作符号与运算命令意义
(())用于整数的运算、效率很高
let用于证书运算，类似于(())
expr可用于整数运算，还有其他功能
bcLinux下的计算程序、可用于整数及小数运算
$[]用于整数运算
awkawk既可用于整数运算，也可用于小数运算
declare定义变量值和属性，-i参数可用于定义整形变量，做运算

8.1 双小括号(())数值运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@backup /server/scripts]# echo $((6+2))
8
[root@backup /server/scripts]# echo $((6-2))
4
[root@backup /server/scripts]# echo $((6*2))
12
[root@backup /server/scripts]# echo $((6/2))
3
[root@backup /server/scripts]# a=3
[root@backup /server/scripts]# echo $((a=a+1))     #将a赋值给a+1，输出结果
4
[root@backup /server/scripts]# echo $((a+=1))      #相当于a=a+1
5
[root@backup /server/scripts]# echo $((a**2))      #计算a的平方
25

8.2 let数值运算

1
2
3
4
5
6
7
8
9
[root@backup /server/scripts]# sum=10
[root@backup /server/scripts]# let sum=sum+1
[root@backup /server/scripts]# echo $sum
11
[root@backup /server/scripts]# sum1=10
[root@backup /server/scripts]# sum2=20
[root@backup /server/scripts]# let sum=sum1+sum2
[root@backup /server/scripts]# echo $sum
30

8.3 expr数值运算

1
2
3
4
5
6
7
8
9
10
[root@backup /server/scripts]# expr 2 + 2
4
[root@backup /server/scripts]# expr 2 - 2
0
[root@backup /server/scripts]# expr 2 * 2
expr: syntax error
[root@backup /server/scripts]# expr 2 \* 2
4
[root@backup /server/scripts]# expr 2 / 2
1

8.4 bc数值运算

1
2
3
4
5
6
7
8
[root@backup ~]# echo 10+10|bc
20
[root@backup ~]# echo 10+10.5|bc
20.5
[root@backup ~]# echo 10*10.5|bc
105.0
[root@backup ~]# echo 10/10.5|bc
0

8.5 $[] 数值运算

1
2
3
4
5
6
7
8
[root@backup /server/scripts]# echo $[10+10]
20
[root@backup /server/scripts]# echo $[10-10]
0
[root@backup /server/scripts]# echo $[10*10]
100
[root@backup /server/scripts]# echo $[10/10]
1

8.6 awk数值运算

1
2
3
4
5
6
7
8
[root@backup /server/scripts]# echo "10 1.5"|awk '{print $1+$2}'
11.5
[root@backup /server/scripts]# echo "10 1.5"|awk '{print $1-$2}'
8.5
[root@backup /server/scripts]# echo "10 1.5"|awk '{print $1*$2}'
15
[root@backup /server/scripts]# echo "10 1.5"|awk '{print $1/$2}'
6.66667

8.7 declare命令的用法

1
2
3
4
[root@backup ~]# declare -i A=30 B=7
[root@backup ~]# A=A+B
[root@backup ~]# echo $A
37
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla Mongo命令与副本集 http://linuxwf.com/2020/04/15/Mongo%E5%91%BD%E4%BB%A4%E4%B8%8E%E5%89%AF%E6%9C%AC%E9%9B%86/ 2020-04-15T03:01:00.000Z 2020-04-15T03:08:40.000Z

Mongo进阶

第1章 Mongo基本操作

1.1 介绍

CRUD 操作是create(创建)， read(读取)， update(更新)和delete(删除) 文档。
MongoDB 不支持SQL 但是支持自己的丰富的查询语言。
在MongoDB 中，存储在集合中的每个文档都需要一个唯一的_id 字段，作为主键。如果插入的文档省略了该_id字段，则MongoDB 驱动程序将自动为该字段生成一个ObjectId_id。也用于通过更新操作插入的文档upsert: true.
如果文档包含一个_id 字段，该_id 值在集合中必须是唯一的，以避免重复键错误。
在MongoDB 中，插入操作针对单个集合。MongoDB 中的所有写操作都是在单个文档的级别上进行的

1.2 显示命令

1
2
3
4
5
6
7
8
9
10
11
Help: 显示帮助。
db.help() 显示数据库方法的帮助。
db.<collection>.help() 显示收集方法的帮助， <collection>可以是现有的集合或不存在的集合的名称。
show dbs 打印服务器上所有数据库的列表。
use <db> 将当前数据库切换到<db>。该mongoshell 变量db 被设置为当前数据库。
show collections 打印当前数据库的所有集合的列表
show users 打印当前数据库的用户列表。
show roles 打印用于当前数据库的用户定义和内置的所有角色的列表。
show profile 打印需要1 毫秒或更多的五个最近的操作。有关详细信息，请参阅数据库分析器上的文档。
show databases 打印所有可用数据库的列表。
load() 执行一个JavaScript 文件。

1.3 MongoDB CRUD操作

官方文档 https://docs.mongodb.com/manual/crud/

1.插入文件

1
2
3
db.inventory.insertOne()
db.inventory.insertMany()
db.inventory.find( {} )  ---> 查询

单行插入

1
2
3
db.inventory.insertOne(
   { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)

多行插入

1
2
3
4
5
db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },
   { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },
   { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
])

2.查询数据

查询所有

1
2
db.inventory.find( {} )
SELECT * FROM inventory   --> MySQL查询

指定条件查询

1
2
db.inventory.find( { status: "D" } )
SELECT * FROM inventory WHERE status = "D"--> MySQL查询

指定条件下使用查询运算符

从inventory 集合中检索status等于”A”或的所有文档”D”

1
2
db.inventory.find( { status: { $in: [ "A", "D" ] } } )
SELECT * FROM inventory WHERE status in ("A", "D")--> MySQL查询

指定AND条件

检索inventory 集合中status等于”A” 和 qty数量$lt小于30的所有文档

1
2
db.inventory.find( { status: "A", qty: { $lt: 30 } } )
SELECT * FROM inventory WHERE status = "A" AND qty < 30

指定OR条件

检索inventory 集合中status等于”A” 或 qty数量$lt小于30的所有文档

1
2
db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )
SELECT * FROM inventory WHERE status = "A" OR qty < 30--> MySQL查询

指定AND和OR条件

1
2
3
4
5
6
db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")

查看数据库命令

1
2
3
4
5
6
7
8
9
10
11
12
> show dbs
admin 0.000GB
local 0.000GB
test 0.000GB
test2 0.000GB
> use test
switched to db test
> db
test
> show collections
inventory
test

3.更新数据

以下集合为例

1
2
3
4
5
6
7
8
9
10
11
12
db.inventory.insertMany( [
   { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
   { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
   { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }
] );

更新单个文件

1
2
3
4
5
6
7
db.inventory.updateOne(
   { item: "paper" },
   {
     $set: { "size.uom": "cm", status: "P" },
     $currentDate: { lastModified: true }
   }
)

更新多个文件

1
2
3
4
5
6
7
db.inventory.updateMany(
   { "qty": { $lt: 50 } },
   {
     $set: { "size.uom": "in", status: "P" },
     $currentDate: { lastModified: true }
   }
)

更换文件

下面的示例替换集合中的第一个文档， inventory其中：item: "paper"

1
2
3
4
db.inventory.replaceOne(
   { item: "paper" },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)

4.删除文件

以下集合为例

1
2
3
4
5
6
7
db.inventory.insertMany( [
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
] );

删除所有文件

1
db.inventory.deleteMany({})

删除所有符合条件的文档

1
db.inventory.deleteMany({ status : "A" })

仅删除一个符合条件的文档

1
db.inventory.deleteOne( { status: "D" } )

1.4 创建索引

默认情况下，创建索引将阻止数据库上的所有其他操作。在集合上构建索引时，保存集合的数据库对于读取或写入操作是不可用的，直到索引构建完成。任何需要对所有数据库（例如listDatabases）进行读或写锁定的操作将等待前台索引构建完成。
对于可能需要长时间运行的索引创建操作，可以考虑background 选项，这样MongoDB 数据库在索引创建期间仍然是可用的。例如，在people 集合的zipcode 键上创建一个索引，这个过程在后台运行，可以使用如下方式：
db.people.createIndex( { zipcode: 1}, {background: true} )
默认MongoDB 索引创建的background 是false 。
索引优化： db.test.find({“id”:100}).explain()

1.查看执行计划

1
db.test.find({"age":{ $lt: 30 }}).explain()

2.创建索引

1
db.test.createIndex( { age: 1 } )

3.查看索引

1
db.test.getIndexes()

4.再次查看执行计划

1
2
3
关键词
"stage" : "IXSCAN"
"indexName" : "age_1"

第2章 工具介绍

官网地址

1
https://docs.mongodb.com/manual/reference/program/

MongoDB软件包中的核心组件是：mongod核心数据库进程；mongos分片集群的控制器和查询路由器; 以及 mongo交互式MongoDB Shell。

2.1 mongod

1
2
Mongod 是Mongodb 系统的主要守护进程，它处理数据请求，管理数据访问，并执行后台
管理操作。启动进程指定配置文件，控制数据库的行为

2.2 mongos

1
2
3
mongos 对于“ MongoDB Shard”，是用于处理来自应用层的查询的MongoDB 分片配置的路由服务，并确
定此数据在分片集群中的位置， 以完成这些操作。从应用程序的角度来看，一个mongos 实例与任何其他
MongoDB 实例的行为相同

2.3 Mongostat

1
Mongostat 实用程序可以快速概览当前正在运行的mongod 或mongos 实例的状态。mongostat 在功能上类似于UNIX / Linux 文件系统实用程序vmstat，但提供有关的数据mongod 和mongos 实例

2.4 Mongotop

1
2
Mongotop 提供了一种跟踪MongoDB 实例读取和写入数据的时间量的方法。mongotop 提供每个收集级别
的统计信息。默认情况下，mongotop 每秒返回一次值

2.5 Mongooplog

1
2
Mongooplog 是一个简单的工具，可以从远程服务器的复制oplog 轮询操作，并将其应用于本地服务器。此功能支持某些类型的实时迁移，这些迁移要求源服务器保持联机并在整个迁移过程中运行。通常，此命令将采用以下形式:
mongooplog - from mongodb0.example.net --host mongodb1.example.net

第3章 授权认证

3.1 官方网址

1
2
https://docs.mongodb.com/manual/reference/configuration-options/#security-options
https://docs.mongodb.com/manual/tutorial/enable-authentication/

3.2 授权介绍

1
2
3
4
5
用户管理界面
要添加用户， MongoDB 提供了该db.createUser()方法。添加用户时，您可以为用户分配色以授予权限。
注意：
在数据库中创建的第一个用户应该是具有管理其他用户的权限的用户管理员。
您还可以更新现有用户，例如更改密码并授予或撤销角色。

操作命令

1
2
3
4
5
6
7
8
9
10
11
db.auth() 将用户验证到数据库。
db.changeUserPassword() 更改现有用户的密码。
db.createUser() 创建一个新用户。
db.dropUser() 删除单个用户。
db.dropAllUsers() 删除与数据库关联的所有用户。
db.getUser() 返回有关指定用户的信息。
db.getUsers() 返回有关与数据库关联的所有用户的信息。
db.grantRolesToUser() 授予用户角色及其特权。
db.removeUser() 已过时。从数据库中删除用户。
db.revokeRolesFromUser() 从用户中删除角色。
db.updateUser() 更新用户数据。

3.3 创建用户和角色

1.创建管理用户

1
2
3
4
5
6
7
8
9
10
11
12
13
14
mongo db01:27017
use admin 
db.createUser(
{
user: "admin",
pwd: "123456",
roles:[ 
{ 
role: "root", 
db:"admin"
}
  ]
}
)

2.查看创建的用户

1
db.getUsers()

3.配置文件添加权限认证参数

1
2
3
4
security: #认证
authorization: enabled 
#启用或者禁用基于角色的访问控制来管理每个用户对数据库资源和操作的访问
enabled 或者 disables

4.重启mongo

1
2
mongod -f /opt/mongo_27017/conf/mongodb.conf --shutdown
mongod -f /opt/mongo_27017/conf/mongodb.conf

5.登录

配置问权限认证后需要重启节点，再次登陆如果不使用账号密码就查看不了数据

1
mongo db01:27017 -uadmin -p --authenticationDatabase admin

6.创建其他用户

1
2
3
4
5
6
7
8
9
use test
db.createUser(
  {
    user: "mysun",
    pwd: "123456",
    roles: [ { role: "readWrite", db: "write" },
             { role: "read", db: "read" } ]
  }
)

7.创建测试数据

1
2
3
4
5
6
7
8
9
10
11
12
13
use write
db.write.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.write.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.write.insert({"name":"yazhang","age":28,"ad":"北京市朝阳区"})
db.write.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区"})
db.write.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区","sex":"boy"})

use read
db.read.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.read.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.read.insert({"name":"yazhang","age":28,"ad":"北京市朝阳区"})
db.read.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区"})
db.read.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区","sex":"boy"})

8.退出admin，使用mysun用户登录

1
2
3
4
5
6
7
8
mongo db01:27017 -umysun -p --authenticationDatabase test
use write
db.write.find()
db.write.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})

use read
db.read.find()
db.read.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})

第4章 副本集配置

4.1 官方网站

1
https://docs.mongodb.com/manual/replication/

在MongoDB中复制
副本集是一组mongod维护相同数据集的实例。一个副本集包含多个数据承载节点和一个仲裁器节点（可选）。在数据承载节点中，只有一个成员被视为主要节点，而其他节点则被视为次要节点。

所述主节点接收所有的写操作。副本集只能有一个能够确认与 写入有关的写入的主数据库。尽管在某些情况下，另一个mongod实例可能会暂时认为自己也是主要实例。 [1]主数据库在其操作日志（即oplog）中记录对其数据集的所有更改

该次级复制初级的OPLOG和应用操作的数据集，使得次级数据集反映了主要的数据集。如果主要节点不可用，则符合条件的次要节点将进行选举以自行选举新的主要节点。

您可以将一个额外的mongod实例作为仲裁器添加到副本集 。仲裁者不维护数据集。仲裁程序的目的是通过响应其他副本集成员的心跳和选举请求来维护副本集中的仲裁。由于仲裁器不存储数据集，因此它是提供副本集仲裁功能且资源成本比具有数据集的功能齐全的副本集成员便宜的好方法。如果您的副本集成员数为偶数，请添加仲裁程序以majority在主要选举中获得票数。仲裁器不需要专用硬件。

异步复制

辅助节点复制主节点的操作日志，并将操作异步应用于其数据集。通过使次要节点的数据集反映主要节点的数据集，即使一个或多个成员失败，副本集也可以继续运行。

复制延迟和流控制

复制滞后是指将主操作上的写操作复制（即复制）到辅助上所花费的时间 。可以接受一些小的延迟时间，但是随着复制滞后的增加会出现严重的问题，包括在主数据库上增加缓存压力。

从MongoDB 4.2开始，管理员可以限制主数据库应用其写入的速率，以将延迟保持在可配置的最大值以下。majority committedflowControlTargetLagSeconds

默认情况下，流量控制为enabled。

1
2
#注意
为了启用流控制，副本集/分片集群必须具有：featureCompatibilityVersion（FCV） of 4.2并读取关注。也就是说，如果未启用FCV 或禁用了多数读功能，则启用的流控制无效。majority enabled4.2

自动故障转移

当主节点与集合中的其他成员的通信electionTimeoutMillis时间超过配置的时间段（默认为10秒）时，合格的辅助节点将要求选举以提名自己为新的主节点。群集尝试完成新主数据库的选择并恢复正常操作。

4.2 创建多实例副本集

1.创建节点目录和数据目录

1
2
mkdir -p /opt/mongo_2801{7,8,9}/{conf,logs,pid}
mkdir /data/mongo_2801{7,8,9} -p

2.创建配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
cat >/opt/mongo_28017/conf/mongo_28017.conf <<EOF
systemLog:
  destination: file   
  logAppend: true  
  path: /opt/mongo_28017/logs/mongodb.log

storage:
  journal:
    enabled: true
  dbPath: /data/mongo_28017
  directoryPerDB: true
  wiredTiger:
     engineConfig:
        cacheSizeGB: 0.5 
        directoryForIndexes: true
     collectionConfig:
        blockCompressor: zlib
     indexConfig:
        prefixCompression: true

processManagement:
  fork: true
  pidFilePath: /opt/mongo_28017/pid/mongod.pid

net:
  port: 28017
  bindIp: 127.0.0.1,10.0.1.51

replication:
   oplogSizeMB: 1024 
   replSetName: dba
EOF

3.复制配置文件到其他节点

1
2
cp /opt/mongo_28017/conf/mongo_28017.conf /opt/mongo_28018/conf/mongo_28018.conf
cp /opt/mongo_28017/conf/mongo_28017.conf /opt/mongo_28019/conf/mongo_28019.conf

4.替换端口号

1
2
sed -i 's#28017#28018#g' /opt/mongo_28018/conf/mongo_28018.conf  
sed -i 's#28017#28019#g' /opt/mongo_28019/conf/mongo_28019.conf

5.启动所有节点

1
2
3
4
mongod -f /opt/mongo_27017/conf/mongodb.conf --shutdown
mongod -f /opt/mongo_28017/conf/mongo_28017.conf 
mongod -f /opt/mongo_28018/conf/mongo_28018.conf 
mongod -f /opt/mongo_28019/conf/mongo_28019.conf

6.初始化集群

1
2
3
4
5
6
7
8
9
10
11
12
13
mongo db01:28017
config = {
_id : "dba", 
members : [
{_id : 0, host : "db01:28017"},
{_id : 1, host : "db01:28018"},
{_id : 2, host : "db01:28019"},
] 
}

rs.initiate(config) 

rs.status()  ---> 查看状态

7.插入数据

1
2
3
4
5
6
7
db.inventory.insertMany( [
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
 ]);

8.副本节点登录查看数据

1
2
3
4
5
mongo db01:28018
rs.slaveOk();
show dbs 
use test
db.inventory.find()

9.设置副本可读

1
echo "rs.slaveOk();" > /root/.mongorc.js

4.3 副本集权重调整

1.查看当前副本集配置

1
rs.conf()

2.设置权重

1
2
3
config=rs.conf()
config.members[0].priority=100
rs.reconfig(config)

3.主节点主动降级

1
rs.stepDown()

4.4 增加新节点和删除旧节点

1.创建新节点并启动

1
2
3
4
5
6
mkdir /opt/mongo_28010/{conf,logs,pid} -p
mkdir /data/mongo_28010
cp /opt/mongo_28017/conf/mongo_28017.conf /opt/mongo_28010/conf/mongo_28010.conf
sed -i 's#28017#28010#g' /opt/mongo_28010/conf/mongo_28010.conf
mongod -f /opt/mongo_28010/conf/mongo_28010.conf
mongo db01:28010

2.集群添加节点

1
rs.add("db01:28010")

3.删除节点

1
rs.remove("db01:28010")

4.5 仲裁节点

1.创建新节点并启动

1
2
3
4
5
6
mkdir /opt/mongo_28011/{conf,logs,pid} -p
mkdir /data/mongo_28011
cp /opt/mongo_28017/conf/mongo_28017.conf /opt/mongo_28011/conf/mongo_28011.conf
sed -i 's#28017#28011#g' /opt/mongo_28011/conf/mongo_28011.conf
mongod -f /opt/mongo_28011/conf/mongo_28011.conf
mongo db01:28011

2.将仲裁节点加入集群

1
2
mongo db01:28018
rs.addArb("db01:28011")

第5章 mongo备份与恢复

1.工具介绍

1
2
3
4
5
6
7
#（1）mongoexport/mongoimport
mongoimport提供了一种获取JSON， CSV或TSV中的数据并将其导入mongod 实例的方法。mongoexport提供了一种将数据从mongod实例导出到JSON，CSV或TSV的方法。

#注意
BSON与其他格式之间的转换缺乏完整的类型保真度。因此，您不能将mongoimport和 mongoexport用于往返导入和导出操作。
#（2）mongodump/mongorestore
mongodump提供了一种 从实例创建BSON转储文件的方法mongod，同时 mongorestore还可以还原这些转储。bsondump将BSON转储文件转换为 JSON

2.应用场景

1
2
3
4
5
6
1.异构平台迁移  mysql <---> mongodb
2.同平台，跨大版本：mongodb 2  ----> mongodb 3
mongoexport/mongoimport:json csv

日常备份恢复时使用
mongodump/mongorestore

3.导出工具mongoexport

单表备份

1
mongoexport --port 27017 -d test -c inventory -o /data/inventory.json

单表备份至csv格式

1
2
mongoexport --port 27017 -d test -c test --type=csv -f name,age,ad -o /data/test.csv
#说明：test目标数据库，第二个test目标集合，test.csv要保存的文件，--type指定导出的格式，默认是json，-f后面是需要导出的字段名称，多个字段名用逗号隔开

4.恢复

1
2
3
4
mongoimport --port 27017 -d test -c inventory /data/inventory.json

mongoimport --port 27017 -d test -c test --type=csv --headerline --file  /data/test.csv
# 说明：test目标数据库，第二个test目标集合，test.csv要导入的文件，--type指定导出的格式，默认是json，--headerline批明不导入第一行

5.mysql数据迁移到mongo

1
2
select * from world.city into outfile '/data/city2.csv' fields terminated by ',';
mongoimport --port 27017 -d world -c city --type=csv --headerline --file  /data/city2.csv

6.导出与恢复

1
2
mongodump  --port 27017 -o /data/backup
mongorestore --port 27017 -d world  /data/backup/world/ --drop

7.模拟误删除恢复

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
oplog

db.oplog.rs.find().pretty()
{
"ts" : Timestamp(1572983861, 1),
"t" : NumberLong(13),
"h" : NumberLong("4118963721380445998"),
"v" : 2,
"op" : "c",
"ns" : "wo.$cmd",
"ui" : UUID("cb1848ae-8b34-4c76-b832-158324376723"),
"wall" : ISODate("2019-11-05T19:57:41.679Z"),
"o" : {
"drop" : "ci"
}
}

mongorestore --port 28017 --oplogReplay --oplogLimit "1572983861:1" --drop  /data/backup/

8.Mongodump备份数据

1
2
3
4
5
6
mongodump -h dbhost -d dbname -o dbdirectory

#说明
-h：MongDB所在服务器地址，例如：127.0.0.1，当然也可以指定端口号：127.0.0.1:27017
-d：需要备份的数据库实例，例如：test
-o：备份的数据存放位置，例如：c:\data\dump，当然该目录需要提前建立，在备份完成后，系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据。

9.Mongorestore恢复数据

1
2
3
4
5
6
mongorestore -h dbhost -d dbname -directoryperdb dbdirectory

#说明
-h：MongoDB所在服务器地址
-d：需要恢复的数据库实例，例如：test，当然这个名称也可以和备份时候的不一样，比如test2
-directoryperdb：备份数据所在位置，例如：c:\data\dump\test
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla Mongodb介绍安装 http://linuxwf.com/2020/04/15/Mongodb%E4%BB%8B%E7%BB%8D%E5%AE%89%E8%A3%85/ 2020-04-15T02:56:00.000Z 2020-04-15T02:58:08.000Z

Mongodb介绍安装

第1章 NoSQL 介绍

1.1 NoSQL 简介

NoSQL(NoSQL = Not Only SQL )，意即”不仅仅是SQL”。
在现代的计算系统上每天网络上都会产生庞大的数据量。
这些数据有很大一部分是由关系数据库管理系统（RDMBSs）来处理。1970 年E.F.Codd’s 提出的
关系模型的论文“A relational model of data for large shared data banks”，这使得数据建模和应用程序
编程更加简单。
通过应用实践证明，关系模型是非常适合于客户服务器编程，远远超出预期的利益，今天它是结构化
数据存储在网络和商务应用的主导技术。
NoSQL 是一项全新的数据库革命性运动，早期就有人提出，发展至2009 年趋势越发高涨。NoSQL
的拥护者们提倡运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一概念无疑是一
种全新的思维的注入。

1.2 什么是NoSQL

NoSQL，指的是非关系型的数据库。NoSQL 有时也称作Not Only SQL 的缩写，是对不同于传统的关
系型数据库的数据库管理系统的统称。
对NoSQL最普遍的解释是”非关联型的”，强调Key-Value Stores 和文档数据库的优点，而不是单
纯的反对RDBMS。
NoSQL 用于超大规模数据的存储。（例如谷歌或Facebook 每天为他们的用户收集万亿比特的数据）。
这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。

1.3 为什么使用NoSQL ?

今天我们可以通过第三方平台（如：Google,Facebook 等）可以很容易的访问和抓取数据。

用户的个人信息，社交网络，地理位置，用户生成的数据和用户操作日志已经成倍的增加。我们如果

要对这些用户数据进行挖掘，那SQL 数据库已经不适合这些应用了, NoSQL 数据库的发展也却能很好

的处理这些大的数据。

第2章 MongoDB 简介

Mongodb 由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。，是专为可扩展性，
高性能和高可用性而设计的数据库， 是非关系型数据库中功能最丰富，最像关系型数据库的，它支
持的数据结构非常散，是类似json 的bjson 格式，因此可以存储比较复杂的数据类型。

MongoDB 的（来自于英文单词“了Humongous”，中文含义为“庞大”）是可以应用于各种规模的
企业，各个行业以及各类应用程序的开源数据库。作为一个适用于敏捷开发的数据库，MongoDB 的
的数据模式可以随着应用程序的发展而灵活地更新。

MongoDB 以一种叫做BSON（二进制JSON）的存储形式将数据作为文档存储。具有相似结构的文
档通常被整理成集合。可以把这些集合看成类似于关系数据库中的表： 文档和行相似， 字段和列相
似。

2.1 MongoDB 数据格式

2.1.1 JSON

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON 采用完全独立于语言的文本格
式，但是也使用了类似于C 语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python
等）。这些特性使JSON 成为理想的数据交换语言.易于人阅读和编写，同时也易于机器解析和生成(一
般用于提升网络传输速率)。JSON 的官方MIME 类型是application/json,文件扩展名是.json。
MongoDB 使用JSON（JavaScript ObjectNotation）文档存储记录。
JSON 简单说就是JavaScript 中的对象和数组，通过对象和数组可以表示各种复杂的结构。
对象：
对象在js 中表示为“{}”括起来的内容，数据结构为{key： value,key： value,…}的键值对的
结构，在面向对象的语言中， key 为对象的属性， value 为对应的属性值，所以很容易理解，取值方
法为对象.key 获取属性值，这个属性值的类型可以是数字、字符串、数组、对象几种。
例如： {“FirstName”:”ke”,”LastName”:”me”,”email”:”hikeme@aa”}
取值方式和所有语言中一样,使用key 获取,字段值的类型可以是数字、字符串、数组、对象几种。

2.1.2 BSON

BSON 是一种类JSON 的一种二进制形式的存储格式，简称Binary JSON，它和JSON 一样，支持内
嵌的文档对象和数组对象，但是BSON 有JSON 没有的一些数据类型，如Date 和BinData 类型。
它的优点是灵活性高，但它的缺点是空间利用率不是很理想。
BSON 有三个特点：轻量性、可遍历性、高效性。
对JSON 来说，数据存储是无类型的，比如你要修改基本一个值，从9 到10，由于从一个字符变成
了两个，所以可能其后面的所有内容都需要往后移一位才可以。而使用BSON，你可以指定这个列为
数字列，那么无论数字从9 长到10 还是100，我们都只是在存储数字的那一位上进行修改，不会导
致数据总长变大。当然，在MongoDB 中，如果数字从整形增大到长整型，还是会导致数据总长变大
的。
有时BSON 相对JSON 来说也并没有空间上的优势，比如对{“sex”:1}，在JSON 的存储上1 只使用了一个字节，而如果用BSON，那就是至少4 个字节

2.2 MongoDB 特点

高性能：

Mongodb 提供高性能的数据持久性，尤其是支持嵌入式数据模型减少数据库系统上的I/O
操作，索引支持能快的查询，并且可以包括来嵌入式文档和数组中的键

丰富的语言查询：

Mongodb 支持丰富的查询语言来支持读写操作（CRUD）以及数据汇总，文本搜索和地理空间索引

高可用性：

Mongodb 的复制工具，成为副本集，提供自动故障转移和数据冗余，

水平可扩展性：

Mongodb 提供了可扩展性，作为其核心功能的一部分，分片是将数据分，在一组计算机上。

支持多种存储引擎：

WiredTiger 存储引擎和、MMAPv1 存储引擎和InMemory 存储引擎

2.3 MongoDB 包含的程序

MongoDB Drivers

官方MongoDB 客户端库提供C， C ++， C＃， Java， Node.JS， Perl， PHP，Python， Ruby 和
Scala 驱动程序的参考指南。

MongoDB Stitch

为开发人员提供了一个API 到MongoDB 和其他后端服务。保持MongoDB 的全部功能和灵性，同时
受益于强大的系统来配置细粒度的数据访问控制。

MongoDB Atlas

MongoDB 在云中部署，操作和扩展的最佳方式。适用于AWS，Azure 和Google Cloud Platform。轻
松将数据迁移到MongoDB Atlas，零停机

MongoDB Cloud Manager

是一个用于管理MongoDB 部署的软件包。Ops Manager 提供Ops Manager 监控和Ops Manager 备份，可帮助用户优化群集并降低操作风险

MongoDB Charts

可以最快速最简单的创建Mongodb 可视化图表

MongoDB Connector for BI

MongoDB 商业智能连接器（BI）允许用户使用SQL 创建查询，并使用现有的关系商业智能工具（如
Tableau， MicroStrategy 和Qlik）对其MongoDB Enterprise 数据进行可视化，图形化和报告。

MongoDB Compass

通过从集合中随机抽样一个文档子集，为用户提供其MongoDB 模式的图形视图。采样文件可最大程
度地降低对数据库的影响，并能快速产生结果。有关抽样的更多信息

MongoDB Spark Connector

使用连接器，您可以访问所有使用MongoDB 数据集的Spark 库：用SQL 进行分析的数据集（受益于
自动模式推理），流式传输，机器学习和图形API。您也可以使用连接器与Spark Shell。

第3章 应用场景

1
https://www.zhihu.com/question/32071167

第4章 安装部署

4.1 官方文档

1
https://docs.mongodb.com/manual/

4.2 安装方式

1
https://www.mongodb.com/download-center/enterprise

这里选用tar 包的安装方式

1
mongodb-linux-x86_64-3.6.13.tgz

4.3 目录规划

1
2
3
4
5
6
7
8
9
#下载并解压
yum install libcurl openssl -y
cd /opt/
tar xf mongodb-linux-x86_64-3.6.13.tgz
ln -s mongodb-linux-x86_64-3.6.13 mongodb

#创建文件目录以及数据目录
mkdir /opt/mongo_27017/{conf,logs,pid} -p
mkdir /data/mongo_27017 -p

第5章 配置文件

5.1 创建配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
cat > /opt/mongo_27017/conf/mongodb.conf  << EOF
systemLog:
  destination: file   
  logAppend: true  
  path: /opt/mongo_27017/logs/mongodb.log

storage:
  journal:
    enabled: true
  dbPath: /data/mongo_27017
  directoryPerDB: true
  wiredTiger:
     engineConfig:
        cacheSizeGB: 1
        directoryForIndexes: true
     collectionConfig:
        blockCompressor: zlib
     indexConfig:
        prefixCompression: true

processManagement:
  fork: true
  pidFilePath: /opt/mongo_27017/pid/mongod.pid

net:
  port: 27017
  bindIp: 127.0.0.1,10.0.1.51
EOF

5.2 启动关闭mongo

1
2
/opt/mongodb/bin/mongod -f /opt/mongo_27017/conf/mongodb.conf
/opt/mongodb/bin/mongod -f /opt/mongo_27017/conf/mongodb.conf --shutdown

5.3 检查是否启动

1
2
ps -ef|grep mongo
netstat -lntup|grep 27017

第6章 登录mongo

6.1 写入环境变量

1
2
echo 'PATH=$PATH:/opt/mongodb/bin' >> /etc/profile
source /etc/profile

6.2 创建hosts 解析

1
2
[root@db01 ~]# cat > /etc/hosts <<EOF
10.0.1.51 172.16.1.51 db01

6.3 登录mongo

1
2
/opt/mongodb/bin/mongo
mongo db01:27017

6.4 关闭命令

2 种关闭方式，建议使用mongo 自带的命令

方法1:登陆mongo 使用内置shutdown 命令

1
2
3
4
5
6
7
8
9
[root@db01 ~]# mongo localhost:27017

> use admin
switched to db admin
> db.shutdownServer()
server should be down...
2019-11-05T03:26:54.171+0800 I NETWORK  [thread1] trying reconnect to localhost:27017 (127.0.0.1) failed
2019-11-05T03:26:54.171+0800 W NETWORK  [thread1] Failed to connect to 127.0.0.1:27017, in(checking socket for error after poll), reason: Connection refused
2019-11-05T03:26:54.171+0800 I NETWORK  [thread1] reconnect localhost:27017 (127.0.0.1) failed failed

方法2:启动命令添加–shutdown 命令

1
[mongo@db01 ~]$ mongod -f /opt/mongo_27017/conf/mongodb.conf --shutdown

第7章 警告优化

7.1 内存不足

1
2
3
4
5
6
7
8
#报警内容1：内存不足
2019-11-05T00:24:56.345+0800 I STORAGE  [initandlisten] ** WARNING: The configured WiredTiger cache size is more than 80% of available RAM.

#解决方法：
1.添加内存
2.调整配置文件里的cache大小
[root@db01 ~]# grep "cacheSizeGB" /opt/mongo_27017/conf/monogdb.conf
cacheSizeGB: 1

7.2 配置访问控制参数

1
2
3
4
#报警内容2：配置访问控制参数
2019-11-05T00:24:56.345+0800 I STORAGE  [initandlisten] **          See http://dochub.mongodb.org/core/faq-memory-diagnostics-wt
2019-11-05T00:24:57.129+0800 I CONTROL  [initandlisten] ** WARNING: Access control is not enabled for the database.
2019-11-05T00:24:57.129+0800 I CONTROL  [initandlisten] **          Read and write access to data and configuration is unrestricted.

7.3 普通用户启动

1
2
3
4
5
6
7
8
9
10
11
12
#报警内容3：不是以普通用户启动
2019-11-05T00:24:57.129+0800 I CONTROL  [initandlisten] ** WARNING: You are running this process as the root user, which is not recommended.

#解决方法：
mongod -f /opt/mongo_27017/conf/mongodb.conf --shutdown
useradd mongo
echo "123456"|passwd --stdin mongo
chown -R mongo:mongo /opt/
chown -R mongo:mongo /data/
su - mongo
mongod -f /opt/mongo_27017/conf/mongodb.conf
mongo db01:27017

7.4 never

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#报警内容4：We suggest setting it to 'never'
2019-11-05T00:24:57.129+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2019-11-05T00:24:57.129+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'

2019-11-05T00:24:57.129+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2019-11-05T00:24:57.129+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'

#解决方法：
1.临时解决
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag

2.官方脚本  ##推荐
[root@db01 ~]# cat /etc/init.d/disable-transparent-hugepages
#!/bin/bash
### BEGIN INIT INFO
# Provides:          disable-transparent-hugepages
# Required-Start:    $local_fs
# Required-Stop:
# X-Start-Before:    mongod mongodb-mms-automation-agent
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Disable Linux transparent huge pages
# Description:       Disable Linux transparent huge pages, to improve
#                    database performance.
### END INIT INFO

case $1 in
  start)
    if [ -d /sys/kernel/mm/transparent_hugepage ]; then
      thp_path=/sys/kernel/mm/transparent_hugepage
    elif [ -d /sys/kernel/mm/redhat_transparent_hugepage ]; then
      thp_path=/sys/kernel/mm/redhat_transparent_hugepage
    else
      return 0
    fi

    echo 'never' > ${thp_path}/enabled
    echo 'never' > ${thp_path}/defrag

    re='^[0-1]+$'
    if [[ $(cat ${thp_path}/khugepaged/defrag) =~ $re ]]
    then
      # RHEL 7
      echo 0  > ${thp_path}/khugepaged/defrag
    else
      # RHEL 6
      echo 'no' > ${thp_path}/khugepaged/defrag
    fi

    unset re
    unset thp_path
    ;;
esac

赋予脚本权限

1
chmod 755 /etc/init.d/disable-transparent-hugepages

加入开机自启动

1
2
chkconfig --add disable-transparent-hugepages
chkconfig --list|grep disable

7.5 用户访问控制

配置文件增加用户认证的配置参数

1
2
security:
authorization: enabled

第8章 mongodb 默认存在的库

1
2
3
4
> show dbs
admin   0.000GB----->系统预留库,MongoDB 系统管理库
config  0.000GB----->MongoDB 配置信息库
local   0.000GB----->本地预留库,存储关键日志

操作命令：

1
2
3
4
show databases/show dbs
show tables/show collections
use admin
db/select database()
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla MySQL配置文件参数 http://linuxwf.com/2020/04/15/MySQL%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E5%8F%82%E6%95%B0/ 2020-04-15T02:50:00.000Z 2020-04-15T02:51:27.000Z

MySQL配置文件参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[mysqld]
user=mysql   # 用户
basedir=/usr/local/mysql   # 程序路径
datadir=/data/mysql/data   # 数据路径
server_id=51               # 服务器编号, 1-65535 
socket=/tmp/mysql.sock     # socket文件位置
secure-file-priv=/tmp      # into outfile 的安全路径 
innodb_data_file_path=ibdata1:12M;ibdata2:512M:autoextend #共享表空间文件设置
autocommit=0  #自动提交功能
log_error=/tmp/mysql.err  #错误日志位置
log_bin=/data/binlog/mysql-bin  #二进制日志位置
binlog_format=row  #二进制日志记录格式
gtid-mode=on                                              #gtid开关
enforce-gtid-consistency=true                             #强制GTID一致性
slow_query_log=1                               ## 慢日志开关
slow_query_log_file=/data/mysql/slow.log       ## 日志存放位置
long_query_time=0.1                            ## 设定慢查询时间阈值
log_queries_not_using_indexes                  ## 不走索引的进行记录
#transaction_isolation=READ-UNCOMMITTED   ## 隔离级别
#transaction_isolation=READ-COMMITTED
innodb_flush_method=O_DIRECT   ## 控制IO刷写策略
[mysql]
socket=/tmp/mysql.sock
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 11.分布式架构-MyCAT http://linuxwf.com/2020/04/15/11-%E5%88%86%E5%B8%83%E5%BC%8F%E6%9E%B6%E6%9E%84-MyCAT/ 2020-04-15T02:45:00.000Z 2020-04-15T02:45:57.000Z

第11节 分布式架构-MyCAT

第1章 MyCAT基础架构图

第2章 MyCAT基础架构准备

2.1 环境准备

1
2
两台虚拟机 db01 db02
每台创建四个mysql实例：3307 3308 3309 3310

2.2 删除历史环境

1
2
3
pkill mysqld
rm -rf /data/330* 
mv /etc/my.cnf /etc/my.cnf.bak

2.3 创建相关目录初始化数据

1
2
3
4
5
mkdir /data/33{07..10}/data -p
mysqld --initialize-insecure  --user=mysql --datadir=/data/3307/data --basedir=/usr/local/mysql
mysqld --initialize-insecure  --user=mysql --datadir=/data/3308/data --basedir=/usr/local/mysql
mysqld --initialize-insecure  --user=mysql --datadir=/data/3309/data --basedir=/usr/local/mysql
mysqld --initialize-insecure  --user=mysql --datadir=/data/3310/data --basedir=/usr/local/mysql

2.4 准备配置文件和启动脚本

db01节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
========db01==============
cat >/data/3307/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3307/data
socket=/data/3307/mysql.sock
port=3307
log-error=/data/3307/mysql.log
log_bin=/data/3307/mysql-bin
binlog_format=row
skip-name-resolve
server-id=7
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF

cat >/data/3308/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3308/data
port=3308
socket=/data/3308/mysql.sock
log-error=/data/3308/mysql.log
log_bin=/data/3308/mysql-bin
binlog_format=row
skip-name-resolve
server-id=8
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF

cat >/data/3309/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3309/data
socket=/data/3309/mysql.sock
port=3309
log-error=/data/3309/mysql.log
log_bin=/data/3309/mysql-bin
binlog_format=row
skip-name-resolve
server-id=9
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF
cat >/data/3310/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3310/data
socket=/data/3310/mysql.sock
port=3310
log-error=/data/3310/mysql.log
log_bin=/data/3310/mysql-bin
binlog_format=row
skip-name-resolve
server-id=10
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF

cat >/etc/systemd/system/mysqld3307.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3307/my.cnf
LimitNOFILE = 5000
EOF

cat >/etc/systemd/system/mysqld3308.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3308/my.cnf
LimitNOFILE = 5000
EOF

cat >/etc/systemd/system/mysqld3309.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3309/my.cnf
LimitNOFILE = 5000
EOF
cat >/etc/systemd/system/mysqld3310.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target

[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3310/my.cnf
LimitNOFILE = 5000
EOF

db02节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
========db02===============
cat >/data/3307/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3307/data
socket=/data/3307/mysql.sock
port=3307
log-error=/data/3307/mysql.log
log_bin=/data/3307/mysql-bin
binlog_format=row
skip-name-resolve
server-id=17
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF
cat >/data/3308/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3308/data
port=3308
socket=/data/3308/mysql.sock
log-error=/data/3308/mysql.log
log_bin=/data/3308/mysql-bin
binlog_format=row
skip-name-resolve
server-id=18
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF
cat >/data/3309/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3309/data
socket=/data/3309/mysql.sock
port=3309
log-error=/data/3309/mysql.log
log_bin=/data/3309/mysql-bin
binlog_format=row
skip-name-resolve
server-id=19
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF


cat >/data/3310/my.cnf<<EOF
[mysqld]
basedir=/usr/local/mysql
datadir=/data/3310/data
socket=/data/3310/mysql.sock
port=3310
log-error=/data/3310/mysql.log
log_bin=/data/3310/mysql-bin
binlog_format=row
skip-name-resolve
server-id=20
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
EOF

cat >/etc/systemd/system/mysqld3307.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3307/my.cnf
LimitNOFILE = 5000
EOF

cat >/etc/systemd/system/mysqld3308.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3308/my.cnf
LimitNOFILE = 5000
EOF

cat >/etc/systemd/system/mysqld3309.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3309/my.cnf
LimitNOFILE = 5000
EOF

cat >/etc/systemd/system/mysqld3310.service<<EOF
[Unit]
Description=MySQL Server
Documentation=man:mysqld(8)
Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
After=network.target
After=syslog.target
[Install]
WantedBy=multi-user.target
[Service]
User=mysql
Group=mysql
ExecStart=/usr/local/mysql/bin/mysqld --defaults-file=/data/3310/my.cnf
LimitNOFILE = 5000
EOF

2.5 改权限，启动多实例

1
2
3
4
5
6
7
8
9
10
11
chown -R mysql.mysql /data/*
systemctl start mysqld3307
systemctl start mysqld3308
systemctl start mysqld3309
systemctl start mysqld3310

==============检查=============
mysql -S /data/3307/mysql.sock -e "show variables like 'server_id'"
mysql -S /data/3308/mysql.sock -e "show variables like 'server_id'"
mysql -S /data/3309/mysql.sock -e "show variables like 'server_id'"
mysql -S /data/3310/mysql.sock -e "show variables like 'server_id'"

2.6 节点主从规划

1
2
3
4
5
6
7
8
箭头指向谁是主库
    10.0.1.51:3307    <----->  10.0.1.52:3307
    10.0.1.51:3309    ------>  10.0.1.51:3307
    10.0.1.52:3309    ------>  10.0.1.52:3307

    10.0.1.52:3308  <----->    10.0.1.51:3308
    10.0.1.52:3310  ----->     10.0.1.52:3308
    10.0.1.51:3310  ----->     10.0.1.51:3308

2.7 分片规划

1
2
3
4
5
6
7
8
9
10
shard1：
    Master：10.0.1.51:3307
    slave1：10.0.1.51:3309
    Standby Master：10.0.1.52:3307
    slave2：10.0.1.52:3309
shard2：
    Master：10.0.1.52:3308
    slave1：10.0.1.52:3310
    Standby Master：10.0.1.51:3308
    slave2：10.0.1.51:3310

2.8 开始配置

shard1节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
### shard1
10.0.1.51:3307 <-----> 10.0.1.52:3307
#### db02
mysql  -S /data/3307/mysql.sock -e "grant replication slave on *.* to repl@'10.0.1.%' identified by '123';"
mysql  -S /data/3307/mysql.sock -e "grant all  on *.* to root@'10.0.1.%' identified by '123'  with grant option;"
#### db01
mysql  -S /data/3307/mysql.sock -e "CHANGE MASTER TO MASTER_HOST='10.0.1.52', MASTER_PORT=3307, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3307/mysql.sock -e "start slave;"
mysql  -S /data/3307/mysql.sock -e "show slave status\G"
#### db02
mysql  -S /data/3307/mysql.sock -e "CHANGE MASTER TO MASTER_HOST='10.0.1.51', MASTER_PORT=3307, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3307/mysql.sock -e "start slave;"
mysql  -S /data/3307/mysql.sock -e "show slave status\G"
10.0.1.51:3309 ------> 10.0.1.51:3307
#### db01
mysql  -S /data/3309/mysql.sock  -e "CHANGE MASTER TO MASTER_HOST='10.0.1.51', MASTER_PORT=3307, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3309/mysql.sock  -e "start slave;"
mysql  -S /data/3309/mysql.sock  -e "show slave status\G"
10.0.1.52:3309 ------> 10.0.1.52:3307
#### db02
mysql  -S /data/3309/mysql.sock -e "CHANGE MASTER TO MASTER_HOST='10.0.1.52', MASTER_PORT=3307, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3309/mysql.sock -e "start slave;"
mysql  -S /data/3309/mysql.sock -e "show slave status\G"

shard2节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
### shard2
10.0.1.52:3308 <-----> 10.0.1.51:3308
#### db01
mysql  -S /data/3308/mysql.sock -e "grant replication slave on *.* to repl@'10.0.1.%' identified by '123';"
mysql  -S /data/3308/mysql.sock -e "grant all  on *.* to root@'10.0.1.%' identified by '123'  with grant option;"
#### db02
mysql  -S /data/3308/mysql.sock -e "CHANGE MASTER TO MASTER_HOST='10.0.1.51', MASTER_PORT=3308, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3308/mysql.sock -e "start slave;"
mysql  -S /data/3308/mysql.sock -e "show slave status\G"
#### db01
mysql  -S /data/3308/mysql.sock -e "CHANGE MASTER TO MASTER_HOST='10.0.1.52', MASTER_PORT=3308, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3308/mysql.sock -e "start slave;"
mysql  -S /data/3308/mysql.sock -e "show slave status\G"
10.0.1.52:3310 -----> 10.0.1.52:3308
#### db02
mysql  -S /data/3310/mysql.sock -e "CHANGE MASTER TO MASTER_HOST='10.0.1.52', MASTER_PORT=3308, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3310/mysql.sock -e "start slave;"
mysql  -S /data/3310/mysql.sock -e "show slave status\G"
10.0.1.51:3310 -----> 10.0.1.51:3308
#### db01
mysql  -S /data/3310/mysql.sock -e "CHANGE MASTER TO MASTER_HOST='10.0.1.51', MASTER_PORT=3308, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';"
mysql  -S /data/3310/mysql.sock -e "start slave;"
mysql  -S /data/3310/mysql.sock -e "show slave status\G"

2.9 检测主从状态

1
2
3
4
5
6
7
8
9
10
11
12
13
2.9 检测主从状态
mysql -S /data/3307/mysql.sock -e "show slave status\G"|grep "Running:"
mysql -S /data/3308/mysql.sock -e "show slave status\G"|grep "Running:"
mysql -S /data/3309/mysql.sock -e "show slave status\G"|grep "Running:"
mysql -S /data/3310/mysql.sock -e "show slave status\G"|grep "Running:"

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
注：如果中间出现错误，在每个节点进行执行以下命令
mysql -S /data/3307/mysql.sock -e "stop slave; reset slave all;"
mysql -S /data/3308/mysql.sock -e "stop slave; reset slave all;"
mysql -S /data/3309/mysql.sock -e "stop slave; reset slave all;"
mysql -S /data/3310/mysql.sock -e "stop slave; reset slave all;"
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

2.10 MySQL分布式架构介绍

1
2
3
1. schema拆分及业务分库
2. 垂直拆分-分库分表
3. 水平拆分-分片

2.11 企业代表产品

1
2
3
4
5
6
7
8
9
360 Atlas-Sharding
Alibaba  cobar 
Mycat
TDDL
Heisenberg
Oceanus
Vitess
OneProxy 
DRDS

第3章 MyCAT安装

3.1 预先安装Java运行环境

1
yum -y install java

3.2 下载

1
2
Mycat-server-xxxxx.linux.tar.gz
http://dl.mycat.io/

3.3 解压文件

1
tar xf Mycat-server-1.6.7.3-release-20190927161129-linux.tar.gz

3.4 软件目录结构

1
2
[root@db01 /usr/local/mycat]# ls
bin  catlet  conf  lib  logs  version.txt

3.5 启动和连接

1
2
3
4
5
6
7
8
9
10
##配置环境变量
vim /etc/profile
export PATH=/usr/local/mycat/bin:$PATH
source /etc/profile

##启动
mycat start

##连接mycat：
mysql -uroot -p123456 -h 127.0.0.1 -P8066

3.6 配置文件介绍

1
2
3
4
5
6
7
8
9
10
##logs目录:
wrapper.log       ---->mycat启动日志
mycat.log         ---->mycat详细工作日志
##conf目录:
schema.xml      
##主配置文件（读写分离、高可用、分布式策略定制、节点控制）
server.xml
##mycat软件本身相关的配置
rule.xml 
##分片规则配置文件,记录分片规则列表、使用方法等

第4章 应用前环境准备

4.1 用户创建及数据库导入

1
2
3
4
5
6
7
8
db01:
mysql -S /data/3307/mysql.sock 
grant all on *.* to root@'10.0.1.%' identified by '123';
source /root/world.sql

mysql -S /data/3308/mysql.sock 
grant all on *.* to root@'10.0.1.%' identified by '123';
source /root/world.sql

4.2 配置文件处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@db01 ~]# cd /usr/local/mycat/conf
[root@db01 ~]# mv schema.xml schema.xml.bak
[root@db01 /usr/local/mycat/conf]# vim schema.xml
<?xml version="1.0"?>  
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">  
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1"> 
</schema>  
    <dataNode name="dn1" dataHost="localhost1" database= "world" />  
    <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1"> 
        <heartbeat>select user()</heartbeat>  
    <writeHost host="db1" url="10.0.1.51:3307" user="root" password="123"> 
            <readHost host="db2" url="10.0.1.51:3309" user="root" password="123" /> 
    </writeHost> 
    </dataHost>  
</mycat:schema>

第5章 配置文件简单介绍

5.1 逻辑库：schema

1
2
<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1"> 
</schema>

5.2 数据节点:datanode

1
<dataNode name="dn1" dataHost="localhost1" database= "world" />

5.3 数据主机：datahost(w和r)

1
2
3
4
5
6
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1"> 
        <heartbeat>select user()</heartbeat>  
    <writeHost host="db1" url="10.0.1.51:3307" user="root" password="123"> 
            <readHost host="db2" url="10.0.1.51:3309" user="root" password="123" /> 
    </writeHost> 
    </dataHost>

第6章 读写分离测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
##重启mycat
[root@db01 /usr/local/mycat/conf]# mycat restart
Stopping Mycat-server...
Stopped Mycat-server.
Starting Mycat-server...
##读写分离测试
mysql -uroot -p123456 -h 127.0.0.1 -P8066
mysql> show databases;
mysql> use TESTDB
mysql> select @@server_id;
+-------------+
| @@server_id |
+-------------+
|           9 |
+-------------+
1 row in set (0.01 sec)

mysql> begin;select @@server_id;commit;
Query OK, 0 rows affected (0.00 sec)

+-------------+
| @@server_id |
+-------------+
|           7 |
+-------------+
1 row in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

##总结： 
以上案例实现了1主1从的读写分离功能，写操作落到主库，读操作落到从库.如果主库宕机，从库不能在继续提供服务了。

第7章 配置读写分离及高可用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
[root@db01 /usr/local/mycat/conf]# mv schema.xml schema.xml.rw
[root@db01 /usr/local/mycat/conf]# vim schema.xml

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">  
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="sh1"> 
</schema>  
    <dataNode name="sh1" dataHost="wufei1" database= "world" />  
    <dataHost name="wufei1" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1"> 
        <heartbeat>select user()</heartbeat>  
    <writeHost host="db1" url="10.0.1.51:3307" user="root" password="123">
            <readHost host="db2" url="10.0.1.51:3309" user="root" password="123" /> 
    </writeHost> 
    <writeHost host="db3" url="10.0.1.52:3307" user="root" password="123"> 
            <readHost host="db4" url="10.0.1.52:3309" user="root" password="123" />
    </writeHost>        
    </dataHost>  
</mycat:schema>

[root@db01 /usr/local/mycat/conf]# mycat restart
Stopping Mycat-server...
Stopped Mycat-server.
Starting Mycat-server...

真正的 writehost：负责写操作的writehost  
standby  writeHost  ：和readhost一样，只提供读服务

##当写节点宕机后，后面跟的readhost也不提供服务，这时候standby的writehost就提供写服务，后面跟的readhost提供读服务

##测试：
mysql -uroot -p123456 -h 127.0.0.1 -P 8066
show variables like 'server_id';
##读写分离测试
 mysql -uroot -p -h 127.0.0.1 -P8066
 use TESTDB
 select @@server_id;    -----> 9  17  19
 begin;select @@server_id;commit;   -----> 7
 ##对db01 3307节点进行关闭和启动,测试读写操作
systemctl stop mysqld3307
mysql -uroot -p123456 -h 127.0.0.1 -P8066
mysql> select @@server_id;  ----> 19
mysql>  begin;select @@server_id;commit;  ----> 17

systemctl start mysqld3307
mysql -uroot -p123456 -h 127.0.0.1 -P8066
mysql> select @@server_id;  ----> 7 9 19
mysql>  begin;select @@server_id;commit;  ----> 17

第8章 配置中的属性介绍

balance

1
2
3
4
5
6
## balance属性
负载均衡类型，目前的取值有3种： 
 balance="0", 不开启读写分离机制，所有读操作都发送到当前可用的writeHost上。 
 balance="1"，全部的readHost与standby writeHost参与select语句的负载均衡，简单的说，
 当双主双从模式(M1->S1，M2->S2，并且M1与 M2互为主备)，正常情况下，M2,S1,S2都参与select语句的负载均衡。 
 balance="2"，所有读操作都随机的在writeHost、readhost上分发。

writeType

1
2
3
4
5
## writeType属性
负载均衡类型，目前的取值有2种： 
1. writeType="0", 所有写操作发送到配置的第一个writeHost，
第一个挂了切到还生存的第二个writeHost，重新启动后已切换后的为主，切换记录在配置文件中:dnindex.properties . 
2. writeType=“1”，所有写操作都随机的发送到配置的writeHost，但不推荐使用

switchType

1
2
3
4
## switchType属性
-1 表示不自动切换 
1 默认值，自动切换 
2 基于MySQL主从同步的状态决定是否切换 ，心跳语句为 show slave status

datahost其他配置

1
2
3
4
5
6
7
8
9
## datahost其他配置
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1"> 

maxCon="1000"：最大的并发连接数
minCon="10" ：mycat在启动之后，会在后端节点上自动开启的连接线程

tempReadHostAvailable="1"
这个一主一从时（1个writehost，1个readhost时），可以开启这个参数，如果2个writehost，2个readhost时
<heartbeat>select user()</heartbeat>  监测心跳

第9章 垂直分表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
mv schema.xml schema.xml.ha 
vim schema.xml

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="sh1">
        <table name="user" dataNode="sh1"/>
        <table name="order_t" dataNode="sh2"/>
</schema>
    <dataNode name="sh1" dataHost="wufei1" database= "taobao" />
    <dataNode name="sh2" dataHost="wufei2" database= "taobao" />
    <dataHost name="wufei1" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1">
        <heartbeat>select user()</heartbeat>
    <writeHost host="db1" url="10.0.1.51:3307" user="root" password="123">
            <readHost host="db2" url="10.0.1.51:3309" user="root" password="123" />
    </writeHost>
    <writeHost host="db3" url="10.0.1.52:3307" user="root" password="123">
            <readHost host="db4" url="10.0.1.52:3309" user="root" password="123" />
    </writeHost>
    </dataHost>
    <dataHost name="wufei2" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1">
        <heartbeat>select user()</heartbeat>
    <writeHost host="db1" url="10.0.1.51:3308" user="root" password="123">
            <readHost host="db2" url="10.0.1.51:3310" user="root" password="123" />
    </writeHost>
    <writeHost host="db3" url="10.0.1.52:3308" user="root" password="123">
            <readHost host="db4" url="10.0.1.52:3310" user="root" password="123" />
    </writeHost>
    </dataHost>
</mycat:schema>

##创建测试库和表:
 mysql -S /data/3307/mysql.sock -e "create database taobao charset utf8;"
 mysql -S /data/3308/mysql.sock -e "create database taobao charset utf8;"
 mysql -S /data/3307/mysql.sock -e "use taobao;create table user(id int,name varchar(20))";
 mysql -S /data/3308/mysql.sock -e "use taobao;create table order_t(id int,name varchar(20))"
 
##重启mycat测试
mycat restart
mysql -uroot -p123456 -h 127.0.0.1 -P8066
mysql> use TESTDB
mysql> insert into order_t values(1,'zs');
mysql> insert into order_t values(2,'ls');
mysql> insert into user values(1,'zs');
mysql> insert into user values(2,'ls');
mysql>  select * from user;
mysql>  select * from order_t;

第10章 MyCAT核心特性——分片（水平拆分）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
分片：对一个"bigtable"，比如说t3表

(1)行数非常多，800w
(2)访问非常频繁

分片的目的：
（1）将大数据量进行分布存储
（2）提供均衡的访问路由

分片策略：
范围 range  800w  1-400w 400w01-800w
取模 mod    取余数
枚举 
哈希 hash 
时间 流水

优化关联查询
全局表
ER分片

第11章 范围分片

1
2
3
比如说t3表
(1)行数非常多，2000w（1-1000w:sh1   1000w01-2000w:sh2）
(2)访问非常频繁，用户访问较离散

范围分片实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
##(1)准备配置文件 
mv schema.xml schema.xml.1  
vim schema.xml
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100" dataNode="sh1">
<table name="t3" dataNode="sh1,sh2" rule="auto-sharding-long" />
</schema>
    <dataNode name="sh1" dataHost="wufei1" database= "taobao" />
    <dataNode name="sh2" dataHost="wufei2" database= "taobao" />
    <dataHost name="wufei1" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1">
        <heartbeat>select user()</heartbeat>
    <writeHost host="db1" url="10.0.1.51:3307" user="root" password="123">
            <readHost host="db2" url="10.0.1.51:3309" user="root" password="123" />
    </writeHost>
    <writeHost host="db3" url="10.0.1.52:3307" user="root" password="123">
            <readHost host="db4" url="10.0.1.52:3309" user="root" password="123" />
    </writeHost>
    </dataHost>
    <dataHost name="wufei2" maxCon="1000" minCon="10" balance="1"  writeType="0" dbType="mysql"  dbDriver="native" switchType="1">
        <heartbeat>select user()</heartbeat>
    <writeHost host="db1" url="10.0.1.51:3308" user="root" password="123">
            <readHost host="db2" url="10.0.1.51:3310" user="root" password="123" />
    </writeHost>
    <writeHost host="db3" url="10.0.1.52:3308" user="root" password="123">
            <readHost host="db4" url="10.0.1.52:3310" user="root" password="123" />
    </writeHost>
    </dataHost>
</mycat:schema>

##(2)查看分片策略的使用方法:
vim rule.xml

<tableRule name="auto-sharding-long">
                <rule>
                        <columns>id</columns>
                        <algorithm>rang-long</algorithm>
                </rule>    
##(3) 函数使用方法
<function name="rang-long"
    class="io.mycat.route.function.AutoPartitionByLong">
    <property name="mapFile">autopartition-long.txt</property>
</function>

##(4) 函数传参   
vim autopartition-long.txt
0-10=0
10-20=1  

##创建测试表：
mysql -S /data/3307/mysql.sock -e "use taobao;create table t3 (id int not null primary key auto_increment,name varchar(20) not null);"

mysql -S /data/3308/mysql.sock  -e "use taobao;create table t3 (id int not null primary key auto_increment,name varchar(20) not null);"

##重启mycat测试
mycat restart
mysql -uroot -p123456 -h 127.0.0.1 -P 8066
insert into t3(id,name) values(1,'a');
insert into t3(id,name) values(2,'b');
insert into t3(id,name) values(3,'c');
insert into t3(id,name) values(4,'d');
insert into t3(id,name) values(11,'aa');
insert into t3(id,name) values(12,'bb');
insert into t3(id,name) values(13,'cc');
insert into t3(id,name) values(14,'dd');

第12章 取模分片（mod-long

]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 10.读写分离架构-Atlas http://linuxwf.com/2020/04/15/10-%E8%AF%BB%E5%86%99%E5%88%86%E7%A6%BB%E6%9E%B6%E6%9E%84-Atlas/ 2020-04-15T02:41:00.000Z 2020-04-15T02:42:34.000Z

第10节 读写分离架构-Atlas

第1章 Atlas介绍

1
2
3
4
5
6
7
8
9
#Atlas是由 Qihoo 360, Web平台部基础架构团队开发维护的一个基于MySQL协议的数据中间层项目。
它是在mysql-proxy 0.8.2版本的基础上，对其进行了优化，增加了一些新的功能特性。
360内部使用Atlas运行的mysql业务，每天承载的读写请求数达几十亿条。
#下载地址
https://github.com/Qihoo360/Atlas/releases
#注意：
1、Atlas只能安装运行在64位的系统上
2、Centos 5.X安装 Atlas-XX.el5.x86_64.rpm，Centos 6.X安装Atlas-XX.el6.x86_64.rpm。
3、后端mysql版本应大于5.1，建议使用Mysql 5.6以上

第2章 安装配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
[root@db03 ~]# yum -y install Atlas-2.2.1.el6.x86_64.rpm
cd /usr/local/mysql-proxy/conf
mv test.cnf test.cnf.bak
cat > test.cnf <<EOF
[mysql-proxy]
admin-username = user
admin-password = pwd
proxy-backend-addresses = 10.0.1.55:3306
proxy-read-only-backend-addresses = 10.0.1.51:3306,10.0.1.53:3306
pwds = repl:3yb5jEku5h4=,mha:O2jBXONX098=
daemon = true
keepalive = true
event-threads = 8
log-level = message
log-path = /usr/local/mysql-proxy/log
sql-log=ON
proxy-address = 0.0.0.0:33060
admin-address = 0.0.0.0:2345
charset=utf8
EOF

#启动atlas
[root@db03 ~]# /usr/local/mysql-proxy/bin/mysql-proxyd test start
OK: MySQL-Proxy of test is started
[root@db03 ~]# netstat -lnp|grep mysql
tcp        0      0 0.0.0.0:33060           0.0.0.0:*               LISTEN      1470/mysql-proxy    
tcp        0      0 0.0.0.0:2345            0.0.0.0:*               LISTEN      1470/mysql-proxy    
tcp6       0      0 :::3306                 :::*                    LISTEN      1214/mysqld         
unix  2      [ ACC ]     STREAM     LISTENING     20238    1214/mysqld          /tmp/mysql.sock

第3章 Atlas功能测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#测试读操作：
mysql -umha -pmha  -h 10.0.1.53 -P 33060 
db03 [(none)]>select @@server_id;
+-------------+
| @@server_id |
+-------------+
|          53 |
+-------------+
1 row in set (0.00 sec)

db03 [(none)]>select @@server_id;
+-------------+
| @@server_id |
+-------------+
|          51 |
+-------------+
1 row in set (0.00 sec)
#测试写操作：
db03 [(none)]>begin;select @@server_id;commit;
Query OK, 0 rows affected (0.00 sec)

+-------------+
| @@server_id |
+-------------+
|          52 |
+-------------+
1 row in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

第4章 生产用户要求

1
2
3
4
5
6
7
8
9
10
#开发人员申请一个应用用户 app(  select  update  insert)  密码123456,要通过10网段登录
1. 在主库中,创建用户
grant select,update,insert on *.* to app@'10.0.1.%' identified by '123456';
2. 在atlas中添加生产用户
[root@db03 ~]# /usr/local/mysql-proxy/bin/encrypt 123456  ----> 制作加密密码
/iZxz+0GRoA=
[root@db03 /usr/local/mysql-proxy/conf]# vim test.cnf
pwds = repl:3yb5jEku5h4=,mha:O2jBXONX098=,app:/iZxz+0GRoA=
/usr/local/mysql-proxy/bin/mysql-proxyd test restart
[root@db03 conf]# mysql -uapp -p123456  -h 10.0.1.53 -P 33060

第5章 Atlas基本管理

连接管理接口

1
[root@db03 ~]# mysql -uuser -ppwd -h127.0.0.1 -P2345

打印帮助

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
db03 [(none)]>select * from help;
+----------------------------+---------------------------------------------------------+
| command                    | description                                             |
+----------------------------+---------------------------------------------------------+
| SELECT * FROM help         | shows this help                                         |
| SELECT * FROM backends     | lists the backends and their state                      |
| SET OFFLINE $backend_id    | offline backend server, $backend_id is backend_ndx's id |
| SET ONLINE $backend_id     | online backend server, ...                              |
| ADD MASTER $backend        | example: "add master 127.0.0.1:3306", ...               |
| ADD SLAVE $backend         | example: "add slave 127.0.0.1:3306", ...                |
| REMOVE BACKEND $backend_id | example: "remove backend 1", ...                        |
| SELECT * FROM clients      | lists the clients                                       |
| ADD CLIENT $client         | example: "add client 192.168.1.2", ...                  |
| REMOVE CLIENT $client      | example: "remove client 192.168.1.2", ...               |
| SELECT * FROM pwds         | lists the pwds                                          |
| ADD PWD $pwd               | example: "add pwd user:raw_password", ...               |
| ADD ENPWD $pwd             | example: "add enpwd user:encrypted_password", ...       |
| REMOVE PWD $pwd            | example: "remove pwd user", ...                         |
| SAVE CONFIG                | save the backends to config file                        |
| SELECT VERSION             | display the version of Atlas                            |
+----------------------------+---------------------------------------------------------+
16 rows in set (0.00 sec)

查询后端所有节点信息

1
2
3
4
5
6
7
8
9
db03 [(none)]> SELECT * FROM backends;
+-------------+----------------+-------+------+
| backend_ndx | address        | state | type |
+-------------+----------------+-------+------+
|           1 | 10.0.1.55:3306 | up    | rw   |
|           2 | 10.0.1.51:3306 | up    | ro   |
|           3 | 10.0.1.53:3306 | up    | ro   |
+-------------+----------------+-------+------+
3 rows in set (0.00 sec)

动态添加删除节点

1
2
3
REMOVE BACKEND 3;               #动态删除节点
ADD SLAVE 10.0.1.53:3306;       #动态添加节点
SAVE CONFIG;#保存配置

常用功能

1
2
3
4
5
SELECT * FROM backends; ----->查了所有节点
SET OFFLINE $backend_id/SET ONLINE $backend_id   --->下线、上线
REMOVE BACKEND $backend_id /ADD SLAVE $backend   --->删除、添加节点
SELECT * FROM pwds  / REMOVE PWD $pwd/ ADD PWD $pwd --->查看用户、密码，在线添加删除
save config;   --->保存配置

第6章 自动分表

6.1 介绍

1
2
3
4
使用Atlas的分表功能时，首先需要在配置文件test.cnf设置tables参数。
tables参数设置格式：数据库名.表名.分表字段.子表数量，
比如：
你的数据库名叫school，表名叫stu，分表字段叫id，总共分为2张表，那么就写为school.stu.id.2，如果还有其他的分表，以逗号分隔即可。

第7章 读写分离建议

1
2
3
MySQL-Router    ---> MySQL官方
ProxySQL         --->Percona
Maxscale         ---> MariaDB
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 9.MHA高可用 http://linuxwf.com/2020/04/15/9-MHA%E9%AB%98%E5%8F%AF%E7%94%A8/ 2020-04-15T02:26:00.000Z 2020-04-15T02:27:17.000Z

MHA高可用

第1章 主从复制架构演变介绍

1.1 基本结构

1
2
3
4
5
（1）一主一从
（2）一主多从
（3）多级主从
（4）双主
（5）循环复制

1.2 高级应用架构演变

1.2.1 高性能架构

1
2
3
4
5
6
7
8
9
读写分离架构(读性能较高)
代码级别
MySQL proxy (Atlas,mysql router,proxySQL(percona),maxscale)、
amoeba(taobao)
xx-dbproxy等。
分布式架构(读写性能都提高):
分库分表——cobar--->TDDL(头都大了),DRDS
Mycat--->DBLE自主研发等。
NewSQL-->TiDB

1.2.2 高可用架构

1
2
3
4
5
（1）单活:MMM架构——mysql-mmm（google）
（2）单活:MHA架构——mysql-master-ha（日本DeNa）,T-MHA
（3）多活:MGR ——5.7 新特性 MySQL Group replication(5.7.17) --->Innodb Cluster  
（4）多活:MariaDB Galera Cluster架构,(PXC)Percona XtraDB Cluster、
MySQL Cluster(Oracle rac)架构

第2章 高可用MHA

2.1 工作原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
主库宕机处理过程
1. 监控节点 (通过配置文件获取所有节点信息)
   系统,网络,SSH连接性
   主从状态,重点是主库

2. 选主
(1) 如果判断从库(position或者GTID),数据有差异,最接近于Master的slave,成为备选主
(2) 如果判断从库(position或者GTID),数据一致,按照配置文件顺序,选主.
(3) 如果设定有权重(candidate_master=1),按照权重强制指定备选主.
    1. 默认情况下如果一个slave落后master 100M的relay logs的话，即使有权重,也会失效.
    2. 如果check_repl_delay=0的化,即使落后很多日志,也强制选择其为备选主
3. 数据补偿
(1) 当SSH能连接,从库对比主库GTID 或者position号,立即将二进制日志保存至各个从节点并且应用(save_binary_logs )
(2) 当SSH不能连接, 对比从库之间的relaylog的差异(apply_diff_relay_logs) 
4. Failover
将备选主进行身份切换,对外提供服务
其余从库和新主库确认新的主从关系
5. 应用透明(VIP)
6. 故障切换通知(send_reprt)
7. 二次数据补偿(binlog_server)
8. 自愈自治(待开发...)

2.2 架构介绍

1
2
3
4
1主2从，master：db01   slave：db02   db03 ）：
MHA 高可用方案软件构成
Manager软件：选择一个从节点安装
Node软件：所有节点都要安装

2.3 MHA软件构成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Manager工具包主要包括以下几个工具：
masterha_manger             启动MHA 
masterha_check_ssh      检查MHA的SSH配置状况 
masterha_check_repl         检查MySQL复制状况 
masterha_master_monitor     检测master是否宕机 
masterha_check_status       检测当前MHA运行状态 
masterha_master_switch  控制故障转移（自动或者手动）
masterha_conf_host      添加或删除配置的server信息

Node工具包主要包括以下几个工具：
这些工具通常由MHA Manager的脚本触发，无需人为操作
save_binary_logs            保存和复制master的二进制日志 
apply_diff_relay_logs       识别差异的中继日志事件并将其差异的事件应用于其他的
purge_relay_logs            清除中继日志（不会阻塞SQL线程）

2.4 MHA环境搭建

2.4.1 规划

1
2
3
主库: 51    node 
从库: 52    node
53    node    manager

2.4.2 准备环境(1主2从GTID)

清理环境

1
2
3
pkill mysqld
rm -rf /data/mysql/data/*
rm -rf /data/binlog/*

准备配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
主库db01：
cat > /etc/my.cnf <<EOF
[mysqld]
basedir=/usr/local/mysql/
datadir=/data/mysql/data
socket=/tmp/mysql.sock
server_id=51
port=3306
secure-file-priv=/tmp
autocommit=0
log_bin=/data/binlog/mysql-bin
binlog_format=row
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
[mysql]
prompt=db01 [\\d]>
EOF

slave1(db02)：
cat > /etc/my.cnf <<EOF
[mysqld]
basedir=/data/mysql
datadir=/data/mysql/data
socket=/tmp/mysql.sock
server_id=52
port=3306
secure-file-priv=/tmp
autocommit=0
log_bin=/data/binlog/mysql-bin
binlog_format=row
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
[mysql]
prompt=db02 [\\d]>
EOF

slave2(db03)：
cat > /etc/my.cnf <<EOF
[mysqld]
basedir=/data/mysql
datadir=/data/mysql/data
socket=/tmp/mysql.sock
server_id=53
port=3306
secure-file-priv=/tmp
autocommit=0
log_bin=/data/binlog/mysql-bin
binlog_format=row
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
[mysql]
prompt=db03 [\\d]>
EOF

初始化数据

1
mysqld --initialize-insecure --user=mysql --basedir=/usr/local/mysql  --datadir=/data/mysql/data

启动数据库

1
2
/etc/init.d/mysqld start
systemctl start mysqld

构建主从

1
2
3
4
5
6
7
8
9
10
11
12
13
master:51slave:52,53

#51
grant replication slave  on *.* to repl@'10.0.1.%' identified by '123';

#52、53
change master to 
master_host='10.0.1.51',
master_user='repl',
master_password='123' ,
MASTER_AUTO_POSITION=1;

start slave;

2.4.3 配置关键程序软连接

1
2
ln -s /data/mysql/bin/mysqlbinlog    /usr/bin/mysqlbinlog
ln -s /data/mysql/bin/mysql          /usr/bin/mysql

2.4.4 配置各节点互信

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
db01：
rm -rf /root/.ssh 
ssh-keygen
cd /root/.ssh 
mv id_rsa.pub authorized_keys
scp -r /root/.ssh 10.0.1.52:/root/
scp -r /root/.ssh 10.0.1.53:/root/
各节点验证
db01:
ssh 10.0.1.51 date
ssh 10.0.1.52 date
ssh 10.0.1.53 date
db02:
ssh 10.0.1.51 date
ssh 10.0.1.52 date
ssh 10.0.1.53 date
db03:
ssh 10.0.1.51 date
ssh 10.0.1.52 date
ssh 10.0.1.53 date

2.4.5 安装软件

下载MHA软件

1
2
mha官网：https://code.google.com/archive/p/mysql-master-ha/
github下载地址：https://github.com/yoshinorim/mha4mysql-manager/wiki/Downloads

所有节点安装Node软件依赖包

1
2
yum -y install perl-DBD-MySQL
rpm -ivh mha4mysql-node-0.56-0.el6.noarch.rpm

在db01主库中创建mha需要的用户

1
grant all privileges on *.* to mha@'10.0.1.%' identified by 'mha';

Manager软件安装（db03）

1
2
# yum install -y perl-Config-Tiny epel-release perl-Log-Dispatch perl-Parallel-ForkManager perl-Time-HiRes
# rpm -ivh mha4mysql-manager-0.56-0.el6.noarch.rpm

2.4.6 配置文件准备(db03)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#创建配置文件目录
 mkdir -p /etc/mha
#创建日志目录
 mkdir -p /var/log/mha/app1
#编辑mha配置文件
vim /etc/mha/app1.cnf
[server default]
manager_log=/var/log/mha/app1/manager        
manager_workdir=/var/log/mha/app1            
master_binlog_dir=/data/binlog       
user=mha                                   
password=mha                               
ping_interval=2
repl_password=123
repl_user=repl
ssh_user=root                               
[server1]                                   
hostname=10.0.1.51
port=3306                                  
[server2]            
hostname=10.0.1.52
port=3306
[server3]
hostname=10.0.1.53
port=3306

2.4.7 状态检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#互信检查
[root@db03 ~]# masterha_check_ssh  --conf=/etc/mha/app1.cnf 
Fri Oct 25 04:29:50 2019 - [warning] Global configuration file /etc/masterha_default.cnf not found. Skipping.
Fri Oct 25 04:29:50 2019 - [info] Reading application default configuration from /etc/mha/app1.cnf..
Fri Oct 25 04:29:50 2019 - [info] Reading server configuration from /etc/mha/app1.cnf..
Fri Oct 25 04:29:50 2019 - [info] Starting SSH connection tests..
Fri Oct 25 04:29:50 2019 - [debug] 
Fri Oct 25 04:29:50 2019 - [debug]  Connecting via SSH from root@10.0.1.51(10.0.1.51:22) to root@10.0.1.52(10.0.1.52:22)..
Fri Oct 25 04:29:50 2019 - [debug]   ok.
Fri Oct 25 04:29:50 2019 - [debug]  Connecting via SSH from root@10.0.1.51(10.0.1.51:22) to root@10.0.1.53(10.0.1.53:22)..
Fri Oct 25 04:29:50 2019 - [debug]   ok.
Fri Oct 25 04:29:51 2019 - [debug] 
Fri Oct 25 04:29:50 2019 - [debug]  Connecting via SSH from root@10.0.1.52(10.0.1.52:22) to root@10.0.1.51(10.0.1.51:22)..
Fri Oct 25 04:29:50 2019 - [debug]   ok.
Fri Oct 25 04:29:50 2019 - [debug]  Connecting via SSH from root@10.0.1.52(10.0.1.52:22) to root@10.0.1.53(10.0.1.53:22)..
Fri Oct 25 04:29:50 2019 - [debug]   ok.
Fri Oct 25 04:29:51 2019 - [debug] 
Fri Oct 25 04:29:51 2019 - [debug]  Connecting via SSH from root@10.0.1.53(10.0.1.53:22) to root@10.0.1.51(10.0.1.51:22)..
Fri Oct 25 04:29:51 2019 - [debug]   ok.
Fri Oct 25 04:29:51 2019 - [debug]  Connecting via SSH from root@10.0.1.53(10.0.1.53:22) to root@10.0.1.52(10.0.1.52:22)..
Fri Oct 25 04:29:51 2019 - [debug]   ok.
Fri Oct 25 04:29:51 2019 - [info] All SSH connection tests passed successfully.

#主从状态检查
[root@db03 ~]# masterha_check_repl  --conf=/etc/mha/app1.cnf
Fri Oct 25 04:51:22 2019 - [warning] Global configuration file /etc/masterha_default.cnf not found. Skipping.
Fri Oct 25 04:51:22 2019 - [info] Reading application default configuration from /etc/mha/app1.cnf..
Fri Oct 25 04:51:22 2019 - [info] Reading server configuration from /etc/mha/app1.cnf..
Fri Oct 25 04:51:22 2019 - [info] MHA::MasterMonitor version 0.56.
Fri Oct 25 04:51:23 2019 - [info] GTID failover mode = 1
Fri Oct 25 04:51:23 2019 - [info] Dead Servers:
Fri Oct 25 04:51:23 2019 - [info] Alive Servers:
Fri Oct 25 04:51:23 2019 - [info]   10.0.1.51(10.0.1.51:3306)
Fri Oct 25 04:51:23 2019 - [info]   10.0.1.52(10.0.1.52:3306)
Fri Oct 25 04:51:23 2019 - [info]   10.0.1.53(10.0.1.53:3306)
Fri Oct 25 04:51:23 2019 - [info] Alive Slaves:
Fri Oct 25 04:51:23 2019 - [info]   10.0.1.52(10.0.1.52:3306)  Version=5.7.26-log (oldest major version between slaves) log-bin:enabled
Fri Oct 25 04:51:23 2019 - [info]     GTID ON
Fri Oct 25 04:51:23 2019 - [info]     Replicating from 10.0.1.51(10.0.1.51:3306)
Fri Oct 25 04:51:23 2019 - [info]   10.0.1.53(10.0.1.53:3306)  Version=5.7.26-log (oldest major version between slaves) log-bin:enabled
Fri Oct 25 04:51:23 2019 - [info]     GTID ON
Fri Oct 25 04:51:23 2019 - [info]     Replicating from 10.0.1.51(10.0.1.51:3306)
Fri Oct 25 04:51:23 2019 - [info] Current Alive Master: 10.0.1.51(10.0.1.51:3306)
Fri Oct 25 04:51:23 2019 - [info] Checking slave configurations..
Fri Oct 25 04:51:23 2019 - [info]  read_only=1 is not set on slave 10.0.1.52(10.0.1.52:3306).
Fri Oct 25 04:51:23 2019 - [info]  read_only=1 is not set on slave 10.0.1.53(10.0.1.53:3306).
Fri Oct 25 04:51:23 2019 - [info] Checking replication filtering settings..
Fri Oct 25 04:51:23 2019 - [info]  binlog_do_db= , binlog_ignore_db= 
Fri Oct 25 04:51:23 2019 - [info]  Replication filtering check ok.
Fri Oct 25 04:51:23 2019 - [info] GTID (with auto-pos) is supported. Skipping all SSH and Node package checking.
Fri Oct 25 04:51:23 2019 - [info] Checking SSH publickey authentication settings on the current master..
Fri Oct 25 04:51:23 2019 - [info] HealthCheck: SSH to 10.0.1.51 is reachable.
Fri Oct 25 04:51:23 2019 - [info] 
10.0.1.51(10.0.1.51:3306) (current master)
 +--10.0.1.52(10.0.1.52:3306)
 +--10.0.1.53(10.0.1.53:3306)

Fri Oct 25 04:51:23 2019 - [info] Checking replication health on 10.0.1.52..
Fri Oct 25 04:51:23 2019 - [info]  ok.
Fri Oct 25 04:51:23 2019 - [info] Checking replication health on 10.0.1.53..
Fri Oct 25 04:51:23 2019 - [info]  ok.
Fri Oct 25 04:51:23 2019 - [warning] master_ip_failover_script is not defined.
Fri Oct 25 04:51:23 2019 - [warning] shutdown_script is not defined.
Fri Oct 25 04:51:23 2019 - [info] Got exit code 0 (Not master dead).

MySQL Replication Health is OK.

2.4.8 开启MHA(db03)：

1
2
[root@db03 ~]# nohup masterha_manager --conf=/etc/mha/app1.cnf --remove_dead_master_conf --ignore_last_failover  < /dev/null> /var/log/mha/app1/manager.log 2>&1 &
[1] 1755

2.4.9 查看MHA状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@db03 ~]# masterha_check_status --conf=/etc/mha/app1.cnf
app1 (pid:1755) is running(0:PING_OK), master:10.0.1.51

[root@db03 ~]# mysql -umha -pmha -h 10.0.1.51 -e "show variables like 'server_id'"
mysql: [Warning] Using a password on the command line interface can be insecure.
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| server_id     | 51    |
+---------------+-------+
[root@db03 ~]# mysql -umha -pmha -h 10.0.1.52 -e "show variables like 'server_id'"
mysql: [Warning] Using a password on the command line interface can be insecure.
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| server_id     | 52    |
+---------------+-------+
[root@db03 ~]# mysql -umha -pmha -h 10.0.1.53 -e "show variables like 'server_id'"
mysql: [Warning] Using a password on the command line interface can be insecure.
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| server_id     | 53    |
+---------------+-------+

2.4.10 故障模拟及处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
### 停主库db01:    
[root@db01 ~]# systemctl stop mysqld

#观察manager  日志 tail -f /var/log/mha/app1/manager 末尾必须显示successfully，才算正常切换成功。 
[root@db03 ~]# tail -f /var/log/mha/app1/manager
Master 10.0.1.51(10.0.1.51:3306) is down!

Check MHA Manager logs at db03:/var/log/mha/app1/manager for details.

Started automated(non-interactive) failover.
Selected 10.0.1.52(10.0.1.52:3306) as a new master.
10.0.1.52(10.0.1.52:3306): OK: Applying all logs succeeded.
10.0.1.53(10.0.1.53:3306): OK: Slave started, replicating from 10.0.1.52(10.0.1.52:3306)
10.0.1.52(10.0.1.52:3306): Resetting slave info succeeded.
Master failover to 10.0.1.52(10.0.1.52:3306) completed successfully.

查看db02变成主库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
db02 [(none)]>show master status;
+------------------+----------+--------------+------------------+------------------------------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set                        |
+------------------+----------+--------------+------------------+------------------------------------------+
| mysql-bin.000003 |      194 |              |                  | 39b29c3b-f69b-11e9-a428-000c29cfb981:1-4 |
+------------------+----------+--------------+------------------+------------------------------------------+
1 row in set (0.00 sec)

db03 [(none)]>show slave status \G
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 10.0.1.52
                  Master_User: repl
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000003
          Read_Master_Log_Pos: 194
               Relay_Log_File: db03-relay-bin.000002
                Relay_Log_Pos: 367
        Relay_Master_Log_File: mysql-bin.000003
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes

启动db01

1
[root@db01 ~]# systemctl start mysqld

恢复主从结构，db02变成主库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
db01 [(none)]>CHANGE MASTER TO 
    -> MASTER_HOST='10.0.1.52',
    -> MASTER_PORT=3306, 
    -> MASTER_AUTO_POSITION=1, 
    -> MASTER_USER='repl', 
    -> MASTER_PASSWORD='123';

db01 [(none)]>show slave status \G
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 10.0.1.52
                  Master_User: repl
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000003
          Read_Master_Log_Pos: 194
               Relay_Log_File: db01-relay-bin.000002
                Relay_Log_Pos: 367
        Relay_Master_Log_File: mysql-bin.000003
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes

修改db03 MHA配置文件

1
2
3
4
[root@db03 ~]# vim /etc/mha/app1.cnf
[server1]
hostname=10.0.1.51
port=3306

启动MHA

1
2
3
4
[root@db03 ~]# nohup masterha_manager --conf=/etc/mha/app1.cnf --remove_dead_master_conf --ignore_last_failover  < /dev/null> /var/log/mha/app1/manager.log 2>&1 &
[1] 1959
[root@db03 ~]# masterha_check_status --conf=/etc/mha/app1.cnf
app1 (pid:1959) is running(0:PING_OK), master:10.0.1.52

2.4.11 Manager额外参数介绍

1
2
3
4
5
6
7
8
9
10
11
12
13
14
说明：
主库宕机谁来接管？
1. 所有从节点日志都是一致的，默认会以配置文件的顺序去选择一个新主。
2. 从节点日志不一致，自动选择最接近于主库的从库
3. 如果对于某节点设定了权重（candidate_master=1），权重节点会优先选择。
但是此节点日志量落后主库100M日志的话，也不会被选择。可以配合check_repl_delay=0，关闭日志量的检查，强制选择候选节点。

(1)  ping_interval=1
#设置监控主库，发送ping包的时间间隔，尝试三次没有回应的时候自动进行failover
(2) candidate_master=1
#设置为候选master，如果设置该参数以后，发生主从切换以后将会将此从库提升为主库，即使这个主库不是集群中事件最新的slave
(3)check_repl_delay=0
#默认情况下如果一个slave落后master 100M的relay logs的话，
MHA将不会选择该slave作为一个新的master，因为对于这个slave的恢复需要花费很长时间，通过设置check_repl_delay=0,MHA触发切换在选择一个新的master的时候将会忽略复制延时，这个参数对于设置了candidate_master=1的主机非常有用，因为这个候选主在切换的过程中一定是新的master

2.4.12 MHA 的vip功能

参数

1
2
vim /etc/mha/app1.cnf
master_ip_failover_script=/usr/local/bin/master_ip_failover

拷贝脚本至指定位置

1
[root@db03 ~]# cp master_ip_failover.txt /usr/local/bin/master_ip_failover

修改脚本内容：

1
2
3
4
5
6
7
8
9
10
11
[root@db03 ~]# vim  /usr/local/bin/master_ip_failover
修改为:
my $vip = '10.0.1.55/24';
my $key = '1';
my $ssh_start_vip = "/sbin/ifconfig eth0:$key $vip";
my $ssh_stop_vip = "/sbin/ifconfig eth0:$key down";

[root@db03 ~]# yum -y install dos2unix
[root@db03 ~]# dos2unix /usr/local/bin/master_ip_failover 
dos2unix: converting file /usr/local/bin/master_ip_failover to Unix format ...
[root@db03 ~]# chmod +x /usr/local/bin/master_ip_failover

主库上，手工生成第一个vip地址

1
2
手工在主库上绑定vip，注意一定要和配置文件中的ethN一致，我的是eth0:1(1是key指定的值)
ifconfig eth0:1 10.0.1.55/24

重启mha

1
2
[root@db03 ~]# nohup masterha_manager --conf=/etc/mha/app1.cnf --remove_dead_master_conf --ignore_last_failover  < /dev/null> /var/log/mha/app1/manager.log 2>&1 &
[root@db03 ~]# masterha_check_status --conf=/etc/mha/app1.cnf

2.4.13 邮件提醒

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
1. 参数：
report_script=/usr/local/bin/send
2. 准备邮件脚本
send_report
(1)准备发邮件的脚本(上传 email_2019-最新.zip中的脚本，到/usr/local/bin/中)
(2)将准备好的脚本添加到mha配置文件中,让其调用
[root@db03 /usr/local/bin]# chmod +x send
[root@db03 /usr/local/bin]# chmod +x sendEmail 
[root@db03 /usr/local/bin]# chmod +x testpl

3. 修改manager配置文件，调用邮件脚本
vi /etc/mha/app1.cnf
report_script=/usr/local/bin/send

（3）停止MHA
masterha_stop --conf=/etc/mha/app1.cnf
（4）开启MHA    
nohup masterha_manager --conf=/etc/mha/app1.cnf --remove_dead_master_conf --ignore_last_failover < /dev/null > /var/log/mha/app1/manager.log 2>&1 &
        
(5) 关闭主库,看警告邮件  
故障修复：
1. 恢复故障节点
（1）实例宕掉
/etc/init.d/mysqld start 
（2）主机损坏，有可能数据也损坏了
备份并恢复故障节点。
2.恢复主从环境
看日志文件：
CHANGE MASTER TO MASTER_HOST='10.0.1.52', MASTER_PORT=3306, MASTER_AUTO_POSITION=1, MASTER_USER='repl', MASTER_PASSWORD='123';
start slave ;
3.恢复manager
3.1 修好的故障节点配置信息，加入到配置文件
[server1]
hostname=10.0.1.51
port=3306
3.2 启动manager   
nohup masterha_manager --conf=/etc/mha/app1.cnf --remove_dead_master_conf --ignore_last_failover < /dev/null > /var/log/mha/app1/manager.log 2>&1 &

2.4.14 binlog server（db03）

参数

1
2
3
4
5
6
7
binlogserver配置：
找一台额外的机器，必须要有5.6以上的版本，支持gtid并开启，我们直接用的第二个slave（db03）
vim /etc/mha/app1.cnf 
[binlog1]
no_master=1
hostname=10.0.1.53
master_binlog_dir=/data/mysql/binlog

创建必要目录

1
2
3
mkdir -p /data/mysql/binlog
chown -R mysql.mysql /data/*
修改完成后，将主库binlog拉过来（从000001开始拉，之后的binlog会自动按顺序过来）

拉取主库binlog日志

1
2
3
4
5
6
7
8
9
cd /data/mysql/binlog     -----》必须进入到自己创建好的目录
mysqlbinlog  -R --host=10.0.1.52 --user=mha --password=mha --raw  --stop-never mysql-bin.000001 &
注意：
拉取日志的起点,需要按照目前从库的已经获取到的二进制日志点为起点
[root@db03 /data/mysql/binlog]# ll
total 12
-rw-r----- 1 root root  177 Oct 25 05:38 mysql-bin.000001
-rw-r----- 1 root root 1199 Oct 25 05:38 mysql-bin.000002
-rw-r----- 1 root root  194 Oct 25 05:38 mysql-bin.000003

重启MHA

1
2
3
[root@db03 ~]# masterha_stop --conf=/etc/mha/app1.cnf
[root@db03 ~]# nohup masterha_manager --conf=/etc/mha/app1.cnf --remove_dead_master_conf --ignore_last_failover < /dev/null > /var/log/mha/app1/manager.log 2>&1 &
[root@db03 ~]# masterha_check_status --conf=/etc/mha/app1.cnf

故障处理

1
2
3
4
5
主库宕机，binlogserver 自动停掉，manager 也会自动停止。
处理思路：
1、重新获取新主库的binlog到binlogserver中
2、重新配置文件binlog server信息
3、最后再启动MHA

第3章 管理员在高可用架构维护的职责

1
2
3
4
5
1. 搭建：MHA+VIP+SendReport+BinlogServer
2. 监控及故障处理
3. 高可用架构的优化
 核心是：尽可能降低主从的延时，让MHA花在数据补偿上的时间尽量减少。
5.7 版本，开启GTID模式，开启从库SQL并发复制。
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla 8.MySQL主从复制 http://linuxwf.com/2020/04/15/8-MySQL%E4%B8%BB%E4%BB%8E%E5%A4%8D%E5%88%B6/ 2020-04-15T02:21:00.000Z 2020-04-15T02:21:59.000Z

第8课 MySQL主从复制

第1章 企业高可用性标准

1.1 全年无故障率(非计划内故障停机)

1
2
3
99.9%                 ----> 0.001*365*24*60=525.6  min
99.99%                ----> 0.0001*365*24*60=52.56 min
99.999%               ----> 0.0001*365*24*60=5.256 min

1.2 高可用架构方案

1
2
3
4
5
6
负载均衡:有一定的高可用性 
LVS  Nginx
主备系统:有高可用性,但是需要切换,是单活的架构
KA ,   MHA, MMM
真正高可用(多活系统): 
NDB Cluster  Oracle RAC  Sysbase cluster   , InnoDB Cluster（MGR）,PXC , MGC

第2章 主从复制

2.1 简介

1
2
3
4
5
6
1.1. 基于二进制日志复制的
1.2. 主库的修改操作会记录二进制日志
1.3. 从库会请求新的二进制日志并回放,最终达到主从数据同步
1.4. 主从复制核心功能:
辅助备份,处理物理损坏                   
扩展新型的架构:高可用,高性能,分布式架构等

2.2 主从复制前提(搭建主从的过程)

1
2
3
4
5
6
## 2.1 两台以上mysql实例 ,server_id,server_uuid不同
## 2.2 主库开启二进制日志
## 2.3 专用的复制用户
## 2.4 保证主从开启之前的某个时间点,从库数据是和主库一致(补课)
## 2.5 告知从库,复制user,passwd,IP port,以及复制起点(change master to)
## 2.6 线程(三个):Dump thread  IO thread  SQL thread 开启(start slave)

第3章 主从复制搭建

3.1 准备两个数据库实例(3307(主),3308(从))

1
略

3.2 修改主库my.cnf 开启二进制日志功能

1
2
3
4
5
6
7
8
9
[root@db01 ~]# vim /data/3307/my.cnf 
[mysqld]
user=mysql
basedir=/usr/local/mysql
datadir=/data/3307/data
server_id=7
socket=/data/3307/mysql.sock
port=3307
log_bin=/data/3307/mysql-bin

3.3 启动所有节点

1
2
systemctl start mysqld3307
systemctl start mysqld3308

3.4 主库创建复制用户(3307 主库)

1
2
# mysql -S /data/3307/mysql.sock 
mysql> grant replication slave on *.* to repl@'10.0.1.%' identified by '123456';

3.5 备份主库数据恢复到从库

1
2
[root@db01 ~]# mysqldump -uroot -S /data/3307/mysql.sock -A --master-data=2 --single-transaction -R -E --triggers >/tmp/full.sql
[root@db01 ~]# mysql -S /data/3308/mysql.sock </tmp/full.sql

3.6 配置从库

1
2
3
4
5
6
7
8
9
[root@db01 ~]# mysql -S /data/3308/mysql.sock 
CHANGE MASTER TO
  MASTER_HOST='10.0.1.51',
  MASTER_USER='repl',
  MASTER_PASSWORD='123456',
  MASTER_PORT=3307,
  MASTER_LOG_FILE='mysql-bin.000001',
  MASTER_LOG_POS=154,
  MASTER_CONNECT_RETRY=10;

3.7 开启主从专用线程

1
start slave ;

3.8 检查状态

1
2
3
4
5
6
7
mysql> show slave status \G
Slave_IO_Running: Yes
Slave_SQL_Running: Yes

[root@db01 ~]# mysql  -S /data/3308/mysql.sock -e "show slave status \G"|grep "Running:";
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes

3.9 如果搭建报错,解决方法

1
2
3
4
stop slave ;
reset slave all;
change master to ...
start slave;

第4章 主从复制的原理

4.1 主从中设置到的文件和线程

4.1.1 线程

1
2
3
4
5
主:
DUMP THREAD
从:
IO  THREAD
SQL THREAD

4.1.2 文件

1
2
3
4
5
6
主:
mysql-bin.000001
从: 
db01-relay.000001     ===>中继日志
master.info                 ===》主库信息记录日志
relay-log.info              ===> 记录中继应用情况信息

4.2 主从复制原理

主从复制原理描述：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
(1) 从库 执行change master to语句 ,将以下信息保存至master.info文件中
(2) 从库 start slave , 从库IO_T和SQL_T生成
(3)Io_T ,读取master.info中主库连接信息(ip , port, user,password)
   连接主库,主库专门开启Dump_T,和从库IO_T进行交互
(5) IO_T,读取 master.info ,复制的起点信息,找主库DUMP要最新的binlog
MASTER_LOG_FILE='mysql-bin.000001',MASTER_LOG_POS=154
(6)主库dump_T,截取最新的binlog,发送给从库IO_T
(7)扩展: 基于TCP/IP网络工作模式,IO_T将日志存储到TCP/Ip缓存中,并返回ACK给主库.
(8) IO_T最终会将缓存中数据,写入到relay_log文件中保存.更新master.info为新位置点.
(9) SQL_T,读取relay-log.info信息,获取上次SQL_T回放的位置点.
(10)SQL_T,根据位置点,向下回放最新的relaylog.并且再次更新relay-log.info文件为最新点.
补充:
(11) 主库dump_T 会持续的监控binlog的变化,一旦有新的日志生成,给从库发一些信号.
(12) 从库 relay_log_purge线程会定期自动清理回放过的relay日志.
细节：
1.主库一旦有新的日志生成，会发送“信号”给binlog dump ，IO线程再请求

第5章 主从故障监控\分析\处理

5.1 线程相关监控

5.1.1 主库信息监控(master.info)

1
2
3
4
5
6
7
8
mysql> show slave status \G
(1) 主库信息监控(master.info)
Master_Host: 10.0.1.51
Master_User: repl
Master_Port: 3307
Connect_Retry: 10
Master_Log_File: mysql-bin.000003
Read_Master_Log_Pos: 154

5.1.2 从库relay-log的应用信息(relay-log.info)

1
2
3
4
(2) 从库relay-log的应用信息(relay-log.info)
Relay_Log_File: db01-relay-bin.000008
Relay_Log_Pos: 367
Relay_Master_Log_File: mysql-bin.000003

5.1.3 从库线程工作状态

1
2
3
4
5
6
7
(3) 从库线程工作状态
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
Last_IO_Errno: 0
Last_IO_Error: 
Last_SQL_Errno: 0
Last_SQL_Error:

5.1.4 过滤复制有关信息

1
2
3
4
5
6
Replicate_Do_DB: 
Replicate_Ignore_DB: 
Replicate_Do_Table: 
Replicate_Ignore_Table: 
Replicate_Wild_Do_Table: 
Replicate_Wild_Ignore_Table:

5.1.5 主从延时时间

1
Seconds_Behind_Master: 0

5.1.6 延时从库的状态

1
2
SQL_Delay: 0
SQL_Remaining_Delay: NULL

5.1.7 GTID复制有关

1
2
Retrieved_Gtid_Set: 
Executed_Gtid_Set:

5.2 主从复制故障分析

5.2.1 IO线程故障

(1) 连接主库 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
(1) 连接主库 
网络不通,防火墙
连接信息错误(ip,port,user,password)

[root@db01 data]# mysql -urepl1 -p123 -h10.0.1.51 -P3307
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (28000): Access denied for user 'repl1'@'db01' (using password: YES)
[root@db01 data]# mysql -urepl -p12311 -h10.0.1.51 -P3307
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (28000): Access denied for user 'repl'@'db01' (using password: YES)
[root@db01 data]# mysql -urepl -p123 -h10.0.1.55 -P3307
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 2003 (HY000): Can't connect to MySQL server on '10.0.1.55' (113)
[root@db01 data]# mysql -urepl -p123 -h10.0.1.51 -P33011
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 2003 (HY000): Can't connect to MySQL server on '10.0.1.51' (111)

解决方法: 
stop slave;
reset slave all; 
重新change master to 
start slave;

主库连接数上线,或者是主库太繁忙

1
2
3
4
5
6
7
8
9
10
11
12
13
show slave  staus \G 
Last_IO_Errno: 1040
Last_IO_Error: error reconnecting to master 'repl@10.0.0.51:3307' - retry-time: 10  retries: 7
处理思路:
拿复制用户,手工连接一下

[root@db01 ~]# mysql -urepl -p123 -h 10.0.0.51 -P 3307 
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1040 (HY000): Too many connections
处理方法:
db01 [(none)]>set global max_connections=300;

(3) 防火墙,网络不通

(2) 请求二进制日志 (最常见报错)

1
2
3
4
5
6
7
(2) 请求日志 (最常见报错)
主库日志损坏 ,丢失,不连续

#说明: 
在主从复制环境中,严令禁止主库中reset master; 可以选择expire 进行定期清理主库二进制日志
#解决方案:
最好的办法是重新构建主库.

5.2.2 SQL 线程故障

SQL线程功能：

1
2
3
(1)读写relay-log.info 
(2)relay-log损坏,断节,找不到
(3)接收到的SQL无法执行

导致SQL线程故障原因分析：

1
2
3
4
5
6
7
回放日志 (为什么SQL语句执行失败?)
1. 版本差异，参数设定不同，比如：数据类型的差异，SQL_MODE影响
2.要创建的数据库对象,已经存在
3.要删除或修改的对象不存在  
4.DML语句不符合表定义及约束时.  
归根揭底的原因都是由于从库发生了写入操作.
Last_SQL_Error: Error 'Can't create database 'db'; database exists' on query. Default database: 'db'. Query: 'create database db'

处理方法(以从库为核心的处理方案)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
方法一：
stop slave; 
set global sql_slave_skip_counter = 1;
#将同步指针向下移动一个，如果多次不同步，可以重复操作。
start slave;
方法二：
/etc/my.cnf
slave-skip-errors = 1032,1062,1007
常见错误代码:
1007:对象已存在
1032:无法执行DML
1062:主键冲突,或约束冲突

但是，以上操作有时是有风险的，最安全的做法就是重新构建主从。把握一个原则,一切以主库为主.

一劳永逸的方法:

1
2
3
4
5
6
7
8
9
10
11
处理建议: 
1. 一切以主库为准.最彻底方法重新构建主从。
2. 将从库设置为只读库,采用读写分离的中间件,防止从库写入
mysql> show variables like '%read_only%';
read_only=ON
super_read_only=ON

了解:
可以借助工具,校验和同步
pt-checksum 
pt-sync

第6章 主从延时

6.1 监控

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
(1) 有没有延时 
show slave status \G 
Seconds_Behind_Master: 0
(2) 延时了多少日志量?
 1) 从库回放了多少日志?
relay-log.info   -----> 从库回放到了哪个点.
 2) 以上位置点对应着主库binlog的位置点.
./db01-relay-bin.000002
501
mysql-bin.000001
335
(3) 看主库的位置点
show master status;
(5) 找到哪一个事件
mysql-bin.000001
335

6.2 主从延时原因分析

1
主库做了修改操作,从库比较长时间才能追上.

6.2.1 外在因素

1
2
3
4
5
网络 
主从硬件差异较大
版本差异
参数因素
从库较多

6.2.2 主库

1
2
3
4
5
6
7
8
9
10
11
(1) 二进制日志写入不及时
[rep]>select @@sync_binlog;
(2) CR的主从复制中,binlog_dump线程,事件为单元,串行传送二进制日志(5.6 5.5)

1. 主库并发事务量大,主库可以并行,传送时是串行
2. 主库发生了大事务,由于是串行传送,会产生阻塞后续的事务.

解决方案:
1. 5.6 开始,开启GTID,实现了GC(group commit)机制,可以并行传输日志给从库IO
2. 5.7 开始,不开启GTID,会自动维护匿名的GTID,也能实现GC,我们建议还是认为开启GTID
3. 大事务拆成多个小事务,可以有效的减少主从延时.

6.2.3 从库

1
2
3
4
5
6
7
8
9
10
11
SQL线程导致的主从延时
在CR复制情况下: 从库默认情况下只有一个SQL,只能串行回放事务SQL
1. 主库如果并发事务量较大,从库只能串行回放
2. 主库发生了大事务,会阻塞后续的所有的事务的运行

解决方案:
1. 5.6 版本开启GTID之后,加入了SQL多线程的特性,但是只能针对不同库(database)下的事务进行并发回放.
2. 5.7 版本开始GTID之后,在SQL方面,提供了基于逻辑时钟(logical_clock),binlog加入了seq_no机制,
真正实现了基于事务级别的并发回放,这种技术我们把它称之为MTS(enhanced multi-threaded slave).
3. 大事务拆成多个小事务,可以有效的减少主从延时.
[https://dev.mysql.com/worklog/task/?id=6314]

第7章 过滤复制

7.1 主库 (了解)

1
2
3
mysql> show master status;
binlog_do_db    白名单 
binlog_ignore_db        黑名单

7.2 从库

1
2
3
4
5
6
7
8
9
10
在SQL_T回放日志,选择部分日志回放
replicate_do_db=world
replicate_do_db=oldguo
replicate_ignore_db 

replicate_do_table=world.t1
replicate_ignore_table

replicate_wild_do_table=world.t*
replicate_wild_ignore_table

7.3 案例

1
2
3
4
5
从库: 
vim /data/3308/my.cnf
replicate_do_db=world

[root@db01 data]# systemctl restart mysqld3308

第8章 延时从库

8.1 介绍

1
是我们认为配置的一种特殊从库.人为配置从库和主库延时N小时.

8.2 为什么要有延时从

1
2
3
4
5
数据库故障?
物理损坏
主从复制非常擅长解决物理损坏.
逻辑损坏
普通主从复制没办法解决逻辑损坏

8.3 配置延时从库

1
2
3
4
5
6
mysql>  STOP SLAVE;   -- 先停止同步
mysql> CHANGE MASTER TO MASTER_DELAY = 300;  -- 设置延迟300s，一般设置3-6个小时，单位是s
mysql> START SLAVE; -- 启动同步
mysql> SHOW SLAVE STATUS \G;  -- 查看状态
SQL_Delay: 300
SQL_Remaining_Delay: NULL

8.4 模拟故障及恢复

(1) 模拟数据(3307)

1
2
3
4
5
6
7
8
create database oss charset utf8mb4; 
use oss;
create table t1(id int);
insert into t1 values(1),(2),(3);
commit;
insert into t1 values(11),(22),(33);

drop database oss;

(2) 停线程(3308)

1
2
mysql> STOP SLAVE;  -- 都停了
mysql> stop slave sql_thread;  --停止SQL线程方法

(3) 截取relaylog 

1
2
3
4
5
6
7
8
9
#起点:
show slave status \G
Relay_Log_File: db01-relay-bin.000002
Relay_Log_Pos: 320

#终点:
mysql> show relaylog events in 'db01-relay-bin.000002';
| db01-relay-bin.000005 | 1401 | Query          |         7 |        1826 | drop database oss    
 db01-relay-bin.000005  1401

(4)截取日志

1
[root@db01 data]# mysqlbinlog --start-position=320 --stop-position=1401 db01-relay-bin.000002 >/tmp/relay.sql

(5)恢复

1
2
3
4
5
6
mysql> set sql_log_bin=0;
mysql> source /tmp/relay.sql
mysql> set sql_log_bin=1;
mysql> show slave status \G
 Slave_IO_Running: Yes
 Slave_SQL_Running: Yes

(6)从库身份解除

1
2
>stop slave;
>reset slave all;

第9章 半同步

1
解决主从数据一致性问题

9.1 半同步复制工作原理的变化

1
2
3
4
5
6
1. 主库执行新的事务,commit时,更新 show master status\G ,触发一个信号给 
2. binlog dump 接收到主库的 show master status\G信息,通知从库日志更新了 
3. 从库IO线程请求新的二进制日志事件 
4. 主库会通过dump线程传送新的日志事件,给从库IO线程 
5. 从库IO线程接收到binlog日志,当日志写入到磁盘上的relaylog文件时,给主库ACK_receiver线程 6. ACK_receiver线程触发一个事件,告诉主库commit可以成功了 
7. 如果ACK达到了我们预设值的超时时间,半同步复制会切换为原始的异步复制.

9.2 配置半同步复制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
加载插件
主:
INSTALL PLUGIN rpl_semi_sync_master SONAME 'semisync_master.so';
从:
INSTALL PLUGIN rpl_semi_sync_slave SONAME 'semisync_slave.so';
查看是否加载成功:
show plugins;
启动:
主:
SET GLOBAL rpl_semi_sync_master_enabled = 1;
从:
SET GLOBAL rpl_semi_sync_slave_enabled = 1;
重启从库上的IO线程
STOP SLAVE IO_THREAD;
START SLAVE IO_THREAD;
查看是否在运行
主:
show status like 'Rpl_semi_sync_master_status';
从:
show status like 'Rpl_semi_sync_slave_status';

第10章 GTID复制

10.1 GTID介绍

1
2
3
4
5
6
GTID(Global Transaction ID)是对于一个已提交事务的唯一编号，并且是一个全局(主从复制)唯一的编号。
它的官方定义如下：
GTID = source_id ：transaction_id
7E11FA47-31CA-19E1-9E56-C43AA21293967:29
什么是sever_uuid，和Server-id 区别？
核心特性: 全局唯一,具备幂等性

10.2 GTID核心参数

1
2
3
4
5
6
7
gtid-mode=on 
enforce-gtid-consistency=true 
log-slave-updates=1 

gtid-mode=on --启用gtid类型，否则就是普通的复制架构 
enforce-gtid-consistency=true --强制GTID的一致性 
log-slave-updates=1 --slave更新是否记入日志

10.3 GTID复制配置过程

10.3.1 清理环境

1
2
3
pkill mysqld
 \rm -rf /data/mysql/data/*
 \rm -rf /data/binlog/*

10.3.2 准备配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
主库db01：
cat > /etc/my.cnf <<EOF
[mysqld]
basedir=/data/mysql/
datadir=/data/mysql/data
socket=/tmp/mysql.sock
server_id=51
port=3306
secure-file-priv=/tmp
autocommit=0
log_bin=/data/binlog/mysql-bin
binlog_format=row
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
[mysql]
prompt=db01 [\\d]>
EOF

slave1(db02)：
cat > /etc/my.cnf <<EOF
[mysqld]
basedir=/data/mysql
datadir=/data/mysql/data
socket=/tmp/mysql.sock
server_id=52
port=3306
secure-file-priv=/tmp
autocommit=0
log_bin=/data/binlog/mysql-bin
binlog_format=row
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
[mysql]
prompt=db02 [\\d]>
EOF

slave2(db03)：
cat > /etc/my.cnf <<EOF
[mysqld]
basedir=/data/mysql
datadir=/data/mysql/data
socket=/tmp/mysql.sock
server_id=53
port=3306
secure-file-priv=/tmp
autocommit=0
log_bin=/data/binlog/mysql-bin
binlog_format=row
gtid-mode=on
enforce-gtid-consistency=true
log-slave-updates=1
[mysql]
prompt=db03 [\\d]>
EOF

10.3.3 初始化数据

1
mysqld --initialize-insecure --user=mysql --basedir=/data/mysql  --datadir=/data/mysql/data

10.3.4 启动数据库

1
systemctl start mysqld

10.3.5 构建主从

1
2
3
4
5
6
7
8
9
10
11
12
13
14
master:51
slave:52,53

51:
grant replication slave  on *.* to repl@'10.0.1.%' identified by '123';

52\53:
change master to 
master_host='10.0.0.51',
master_user='repl',
master_password='123' ,
MASTER_AUTO_POSITION=1;

start slave;

10.3.6 GTID 从库误写入操作处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
查看监控信息: 
Last_SQL_Error: Error 'Can't create database 'oldboy'; database exists' on query. Default database: 'oldboy'. Query: 'create database oldboy'

Retrieved_Gtid_Set: 71bfa52e-4aae-11e9-ab8c-000c293b577e:1-3 
Executed_Gtid_Set: 71bfa52e-4aae-11e9-ab8c-000c293b577e:1-2, 
7ca4a2b7-4aae-11e9-859d-000c298720f6:1

注入空事物的方法： 
stop slave; 
set gtid_next='99279e1e-61b7-11e9-a9fc-000c2928f5dd:3'; 
begin;commit; 
set gtid_next='AUTOMATIC'; 

这里的xxxxx:N 也就是你的slave sql thread报错的GTID，或者说是你想要跳过的GTID。 
最好的解决方案：重新构建主从环境

10.3.7 GTID 复制和普通复制的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
CHANGE MASTER TO
MASTER_HOST='10.0.1.51',
MASTER_USER='repl',
MASTER_PASSWORD='123',
MASTER_PORT=3307,
MASTER_LOG_FILE='mysql-bin.000001',
MASTER_LOG_POS=444,
MASTER_CONNECT_RETRY=10;

change master to 
master_host='10.0.1.51',
master_user='repl',
master_password='123' ,
MASTER_AUTO_POSITION=1;
start slave;

（0）在主从复制环境中，主库发生过的事务，在全局都是由唯一GTID记录的，更方便Failover
（1）额外功能参数（3个）
（2）change master to 的时候不再需要binlog 文件名和position号,MASTER_AUTO_POSITION=1;
（3）在复制过程中，从库不再依赖master.info文件，而是直接读取最后一个relaylog的 GTID号
（4） mysqldump备份时，默认会将备份中包含的事务操作，以以下方式
    SET @@GLOBAL.GTID_PURGED='8c49d7ec-7e78-11e8-9638-000c29ca725d:1';
    告诉从库，我的备份中已经有以上事务，你就不用运行了，直接从下一个GTID开始请求binlog就行。
]]> <link rel="stylesheet" class="aplayer-secondary-style-marker" href="/assets/css/APlayer.min.css"><script src="/assets/js/APlayer.min.js" cla