sRm3tA

ppt.cc/fVjECx ppt.cc/fEnHsx ppt.cc/fRZTnx ppt.cc/fSZ3cx ppt.cc/fLOuCx ppt.cc/fE9Nux ppt.cc/fL5Kyx ppt.cc/fIr1ax ppt.cc/f71Yqx tecmint.com linuxcool.com linux.die.net linux.it.net.cn ostechnix.com unix.com ubuntugeek.com runoob.com man.linuxde.net bit.ly/2EzoUDo bit.ly/2tW6eYT bit.ly/2X6vadl bit.ly/2viLpHU linuxprobe.com linuxtechi.com howtoforge.com linuxstory.org systutorials.com ghacks.net linuxopsys.com v.gd/2P9wTx v.gd/FtfpqE v.gd/eMfHsm v.gd/Ub7mqv v.gd/RReVk0 v.gd/vS3uTI v.gd/4Zxmba

Saturday, 19 November 2011

强大的备份程序:rsync

某人 Windows 下一个硬 Raid5 不太稳定，怀疑芯片快挂了，于是打算把数据全部转移到另一个硬盘上。这个 Raid5 上有几百 G 数据，几万个小目录，几千万个文件，由于这个机器常常挂掉，直接复制是行不通的，于是他用了一些同步软件。同步文件不是一件复杂的事情，软件也多如牛毛，据说该哥们试用了 Karen’s Replicator、SyncToy、Allway Sync，还让老板买了一些别的软件，可是居然没有一个软件完成任务。不是容错能力差受不了硬盘文件错误，就是由于文件数量太大索性直接挂掉。于是一遍一遍重试，搞了四天连一半文件都没搞定，实在受不了了，问我怎么办……
于是我出了我以前出过的一个大法，把 src 和 dst 目录都 smbmount 到一个 linux 机器上，在 linux 机器上 rsync src dst。奇迹发生了，rsync 了一个晚上数据就全过去了。这个问题自然不一定要用这么诡异的方法解决，我只是很奇怪为啥这么多 Windows 下的软件都会不及一个外来妹 rsync……
今天某人一个 avi 死活放不了，我后来建议她试一试 VLC，居然就能放。晕啊，难道我们进入共产主义了，要钱的软件做不过免费/开源的软件了.
-------------------------------------------------------
rsync服务器架设

我们在使用服务器发布我们的网站的时候，通常要考虑到文件的备份，而文件的备份比较高效的备份是增加备份，rsync软件就是这样的一个工具。为了实现多个服务器负载均衡，我们需要这几个服务器之间进行数据同步，而rsync软件也能胜任，下面我们来介绍如何架设rsync服务器来达到文件增量备份和数据同步的功能。
什么是rsync

rsync 是一个快速增量文件传输工具，它可以用于在同一主机备份内部的备分，我们还可以把它作为不同主机网络备份工具之用。本文主要讲述的是如何自架rsync服务器，以实现文件传输、备份和镜像。相对tar和wget来说，rsync 也有其自身的优点，比如速度快、安全、高效。
rsync的安装

在CentOS服务器，我们可以执行以下命令安装

    yum install rsync

对于debian、ubuntu服务器，则是以下命令

    sudo apt-get install rsync

rsync服务器的配置文件rsyncd.conf

下面我们将涉及到三个文件 rsyncd.conf，rsyncd.secrets 和rsyncd.motd。
rsyncd.conf 是rsync服务器主要配置文件。
rsyncd.secrets是登录rsync服务器的密码文件。
rsyncd.motd是定义rysnc 服务器信息的，也就是用户登录信息。
下面我们分别建立这三个文件。

    mkdir /etc/rsyncd

注：在/etc目录下创建一个rsyncd的目录，我们用来存放rsyncd.conf 和rsyncd.secrets文件；

    touch /etc/rsyncd/rsyncd.conf

注：创建rsyncd.conf ，这是rsync服务器的配置文件；

    touch /etc/rsyncd/rsyncd.secrets

注：创建rsyncd.secrets ，这是用户密码文件；

    chmod 600 /etc/rsyncd/rsyncd.secrets

注：为了密码的安全性，我们把权限设为600；

    touch /etc/rsyncd/rsyncd.motd

注：创建rsyncd.motd文件，这是定义服务器信息的文件。
下一就是我们修改 rsyncd.conf 和rsyncd.secrets 和rsyncd.motd 文件的时候了。
rsyncd.conf文件内容：

    # Minimal configuration file for rsync daemon
    # See rsync(1) and rsyncd.conf(5) man pages for help

    # This line is required by the /etc/init.d/rsyncd script
    pid file = /var/run/rsyncd.pid
    port = 873
    address = 192.168.1.171
    #uid = nobody
    #gid = nobody
    uid = root
    gid = root

    use chroot = yes
    read only = yes


    #limit access to private LANs
    hosts allow=192.168.1.0/255.255.255.0 10.0.1.0/255.255.255.0
    hosts deny=*

    max connections = 5
    motd file = /etc/rsyncd/rsyncd.motd

    #This will give you a separate log file
    #log file = /var/log/rsync.log

    #This will log every file transferred - up to 85,000+ per user, per sync
    #transfer logging = yes

    log format = %t %a %m %f %b
    syslog facility = local3
    timeout = 300

    [linuxsirhome]
    path = /home
    list=yes
    ignore errors
    auth users = linuxsir
    secrets file = /etc/rsyncd/rsyncd.secrets
    comment = linuxsir home
    exclude =   beinan/ samba/

    [beinan]
    path = /opt
    list=no
    ignore errors
    comment = optdir
    auth users = beinan
    secrets file = /etc/rsyncd/rsyncd.secrets

密码文件：/etc/rsyncd/rsyncd.secrets的内容格式；

    用户名:密码
    linuxsir:222222
    beinan:333333

注：这里的密码值得注意，为了安全，你不能把系统用户的密码写在这里。比如你的系统用户 linuxsir 密码是 abcdefg ，为了安全，你可以让rsync 中的linuxsir 为 222222 。这和samba的用户认证的密码原理是差不多的；
rsyncd.motd 文件;
它是定义rysnc 服务器信息的，也就是用户登录信息。比如让用户知道这个服务器是谁提供的等；类似ftp服务器登录时，我们所看到的 linuxsir.org ftp ……。当然这在全局定义变量时，并不是必须的，你可以用#号注掉，或删除；我在这里写了一个 rsyncd.motd的内容为：

    +++++++++++++++++++++++++++
    + linuxsir.org rsync 2002-2007 +
    +++++++++++++++++++++++++++

rsyncd.conf文件代码说明

    pid file = /var/run/rsyncd.pid

注：告诉进程写到 /var/run/rsyncd.pid 文件中；

    port = 873

注：指定运行端口，默认是873，您可以自己指定；

    address = 192.168.1.171

注：指定服务器IP地址；

    uid = nobody
    gid = nobdoy

注：服务器端传输文件时，要发哪个用户和用户组来执行，默认是nobody。如果用nobody 用户和用户组，可能遇到权限问题，有些文件从服务器上拉不下来。所以我就偷懒，为了方便，用了root 。不过您可以在定义要同步的目录时定义的模块中指定用户来解决权限的问题。

    use chroot = yes

用chroot，在传输文件之前，服务器守护程序在将chroot 到文件系统中的目录中，这样做的好处是可能保护系统被安装漏洞侵袭的可能。缺点是需要超级用户权限。另外对符号链接文件，将会排除在外。也就是说，你在rsync服务器上，如果有符号链接，你在备份服务器上运行客户端的同步数据时，只会把符号链接名同步下来，并不会同步符号链接的内容；这个需要自己来尝试；

    read only = yes

注：read only 是只读选择，也就是说，不让客户端上传文件到服务器上。还有一个 write only选项，自己尝试是做什么用的吧；

    #limit access to private LANs
    hosts allow=192.168.1.0/255.255.255.0 10.0.1.0/255.255.255.0

注：在您可以指定单个IP，也可以指定整个网段，能提高安全性。格式是ip 与ip 之间、ip和网段之间、网段和网段之间要用空格隔开；

    max connections = 5

注：客户端最多连接数；

    motd file = /etc/rsyncd/rsyncd.motd

注：motd file 是定义服务器信息的，要自己写 rsyncd.motd 文件内容。当用户登录时会看到这个信息。

    log file = /var/log/rsync.log

注：rsync 服务器的日志；

    transfer logging = yes

注：这是传输文件的日志；

    [linuxsirhome]

注：模块，它为我们提供了一个链接的名字，链接到哪呢，在本模块中，链接到了/home目录；要用[name] 形式；

    path = /home

注：指定文件目录所在位置，这是必须指定的；

    auth users = linuxsir

注：认证用户是linuxsir ，是必须在服务器上存在的用户；

    list=yes

注：list 意思是把rsync 服务器上提供同步数据的目录在服务器上模块是否显示列出来。默认是yes 。如果你不想列出来，就no ；如果是no是比较安全的，至少别人不知道你的服务器上提供了哪些目录。你自己知道就行了；

    ignore errors

注：忽略IO错误，详细的请查文档；

    secrets file = /etc/rsyncd/rsyncd.secrets

注：密码存在哪个文件；

    comment = linuxsir home data

注：注释可以自己定义，写什么都行，写点相关的内容就行；

    exclude =   beinan/   samba/

注：exclude 是排除的意思，也就是说，要把/home目录下的beinan和samba 排除在外； beinan/和samba/目录之间有空格分开；
启动rsync 服务器及防火墙的设置

启动rsync服务器
启动rsync 服务器相当简单，–daemon 是让rsync 以服务器模式运行；

    /usr/bin/rsync --daemon --config=/etc/rsyncd/rsyncd.conf

rsync服务器和防火墙
Linux 防火墙是用iptables，所以我们至少在服务器端要让你所定义的rsync 服务器端口通过，客户端上也应该让通过。

    iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 873 -j ACCEPT

查看一下防火墙是不是打开了 873端口；

    iptables -L

通过rsync客户端来同步数据

    rsync -avzP linuxsir@linuxsir.org::linuxsirhome   linuxsirhome

Password: 这里要输入linuxsir的密码，是服务器端提供的，在前面的例子中，我们用的是 222222，输入的密码并不显示出来；输好后就回车；
注：这个命令的意思就是说，用linuxsir 用户登录到服务器上，把linuxsirhome数据，同步到本地目录linuxsirhome上。当然本地的目录是可以你自己定义的，比如 linuxsir也是可以的；当你在客户端上，当前操作的目录下没有linuxsirhome这个目录时，系统会自动为你创建一个；当存在linuxsirhome这个目录中，你要注意它的写权限。
说明：
-a 参数，相当于-rlptgoD，-r 是递归 -l 是链接文件，意思是拷贝链接文件；-p 表示保持文件原有权限；-t 保持文件原有时间；-g 保持文件原有用户组；-o 保持文件原有属主；-D 相当于块设备文件；
-z 传输时压缩；
-P 传输进度；
-v 传输时的进度等信息，和-P有点关系，自己试试。可以看文档；

    rsync -avzP --delete linuxsir@linuxsir.org::linuxsirhome   linuxsirhome

这回我们引入一个 –delete 选项，表示客户端上的数据要与服务器端完全一致，如果 linuxsirhome目录中有服务器上不存在的文件，则删除。最终目的是让linuxsirhome目录上的数据完全与服务器上保持一致；用的时候要小心点，最好不要把已经有重要数所据的目录，当做本地更新目录，否则会把你的数据全部删除；

    rsync -avzP --delete --password-file=rsync.password linuxsir@linuxsir.org::linuxsirhome   linuxsirhome

这次我们加了一个选项 –password-file=rsync.password ，这是当我们以linuxsir用户登录rsync服务器同步数据时，密码将读取 rsync.password 这个文件。这个文件内容只是linuxsir用户的密码。我们要如下做；

    touch rsync.password
    chmod 600 rsync.password
    echo "222222"> rsync.password
    rsync -avzP --delete --password-file=rsync.password linuxsir@linuxsir.org::linuxsirhome   linuxsirhome

注：这样就不需要密码了；其实这是比较重要的，因为服务器通过crond 计划任务还是有必要的；
让rsync 客户端自动与服务器同步数据

编辑crontab
crontab -e
加入如下代码：

    10 0 * * * rsync -avzP --delete --password-file=rsync.password linuxsir@linuxsir.org::linuxsirhome   linuxsirhome

表示每天0点10分执行后面的命令。
--------------------------------------------

sersync,基于rsync+inotify实现数据实时同步

前言

提到数据同步就必然会谈到`rsync`，一般简单的服务器数据传输会使用`ftp/sftp`等方式，但是这样的方式效率不高，不支持差异化增量同步也不支持实时传输。针对数据实时同步需求大多数人会选择`rsync+inotify-tools`的解决方案，但是这样的方案也存在一些缺陷（文章中会具体指出），`sersync`是国人基于前两者开发的工具，不仅保留了优点同时还强化了实时监控，文件过滤，简化配置等功能，帮助用户提高运行效率，节省时间和网络资源。可靠高效的数据实时同步方式

扩展阅读

基于rsync+sersync的服务器文件同步实战 - http://www.markdream.com/technologies/server/syncfile-by-rsync.shtml
通过 rsync sersync 实现高效的数据实时同步架构 - https://www.cnhzz.com/rsync_sersync/
Rsync+sersync实现数据实时同步 - http://www.cnblogs.com/wjoyxt/p/4581410.html
rsync - https://rsync.samba.org/
inotify-tools - https://github.com/rvoicilas/inotify-tools
sersync - http://code.google.com/p/sersync/

原理

Synchronize files and folders between servers -using inotiy and rsync with c++ 服务器实时同步文件，服务器镜像解决方案

sersync主要用于服务器同步，web镜像等功能。基于boost1.43.0,inotify api,rsync command.开发。目前使用的比较多的同步解决方案是inotify-tools+rsync ，另外一个是google开源项目Openduckbill（依赖于inotify- tools），这两个都是基于脚本语言编写的。相比较上面两个项目，本项目优点是：

sersync是使用c++编写，而且对linux系统文件系统产生的临时文件和重复的文件操作进行过滤（详细见附录，这个过滤脚本程序没有实现），所以在结合rsync同步的时候，节省了运行时耗和网络资源。因此更快。
相比较上面两个项目，sersync配置起来很简单，其中bin目录下已经有基本上静态编译的2进制文件，配合bin目录下的xml配置文件直接使用即可。
另外本项目相比较其他脚本开源项目，使用多线程进行同步，尤其在同步较大文件时，能够保证多个服务器实时保持同步状态。
本项目有出错处理机制，通过失败队列对出错的文件重新同步，如果仍旧失败，则按设定时长对同步失败的文件重新同步。
本项目自带crontab功能，只需在xml配置文件中开启，即可按您的要求，隔一段时间整体同步一次。无需再额外配置crontab功能。
本项目socket与http插件扩展，满足您二次开发的需要。

针对上图的设计架构，这里做几点说明，来帮助大家阅读和理解该图

1 ) 线程组线程是等待线程队列的守护线程，当事件队列中有事件产生的时候，线程组守护线程就会逐个唤醒同步线程。当队列中 Inotify 事件较多的时候，同步线程就会被全部唤醒一起工作。这样设计的目的是为了能够同时处理多个 Inotify 事件，从而提升服务器的并发同步能力。同步线程的最佳数量=核数 x 2 + 2。
2 ) 那么之所以称之为线程组线程，是因为每个线程在工作的时候，会根据服务器上新写入文件的数量去建立子线程，子线程可以保证所有的文件与各个服务器同时同步。当要同步的文件较大的时候，这样的设计可以保证每个远程服务器都可以同时获得需要同步的文件。
3 ) 服务线程的作用有三个：

处理同步失败的文件，将这些文件再次同步，对于再次同步失败的文件会生成 rsync_fail_log.sh 脚本，记录失败的事件。
每隔10个小时执行 rsync_fail_log.sh 脚本一次，同时清空脚本。
crontab功能，可以每隔一定时间，将所有路径整体同步一次。

4 ) 过滤队列的建立是为了过滤短时间内产生的重复的inotify信息，例如在删除文件夹的时候，inotify就会同时产生删除文件夹里的文件与删除文件夹的事件，通过过滤队列，当删除文件夹事件产生的时候，会将之前加入队列的删除文件的事件全部过滤掉，这样只产生一条删除文件夹的事件，从而减轻了同步的负担。同时对于修改文件的操作的时候，会产生临时文件的重复操作。

角色

注意主从配置的区别，记得调整SELinux和防火墙

iptables配置实践 - https://wsgzao.github.io/post/iptables/
LTMP手动编译安装以及全自动化部署实践 - https://wsgzao.github.io/post/ltmp/

服务器A（主服务器）
服务器B（从服务器/备份服务器）
rsync默认TCP端口为873

服务器B

#在服务器B上安装rsync
cd /app/local
wget  http://rsync.samba.org/ftp/rsync/src/rsync-3.1.1.tar.gz
tar zxf rsync-3.1.1.tar.gz
cd rsync-3.1.1
./configure
make && make install


#设置rsync的配置文件
vi /etc/rsyncd.conf

#服务器B上的rsyncd.conf文件内容
uid=root
gid=root
#最大连接数
max connections=36000
#默认为true，修改为no，增加对目录文件软连接的备份 
use chroot=no
#定义日志存放位置
log file=/var/log/rsyncd.log
#忽略无关错误
ignore errors = yes
#设置rsync服务端文件为读写权限
read only = no 
#认证的用户名与系统帐户无关在认证文件做配置，如果没有这行则表明是匿名
auth users = rsync
#密码认证文件，格式(虚拟用户名:密码）
secrets file = /etc/rsync.pass
#这里是认证的模块名，在client端需要指定，可以设置多个模块和路径
[rsync]
#自定义注释
comment  = rsync
#同步到B服务器的文件存放的路径
path=/app/data/site/
[img]
comment  = img
path=/app/data/site/img

#创建rsync认证文件  可以设置多个，每行一个用户名:密码，注意中间以“:”分割
echo "rsync:rsync" > /etc/rsync.pass

#设置文件所有者读取、写入权限
chmod 600 /etc/rsyncd.conf  
chmod 600 /etc/rsync.pass  

#启动服务器B上的rsync服务
#rsync --daemon -v
rsync --daemon

#监听端口873
netstat -an | grep 873
lsof -i tcp:873

COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
rsync   31445 root    4u  IPv4 443872      0t0  TCP *:rsync (LISTEN)
rsync   31445 root    5u  IPv6 443873      0t0  TCP *:rsync (LISTEN)


#设置rsync为服务启动项（可选）
echo "/usr/local/bin/rsync --daemon" >> /etc/rc.local

#要 Kill rsync 进程，不要用 kill -HUP {PID} 的方式重启进程，以下3种方式任选
#ps -ef|grep rsync|grep -v grep|awk '{print $2}'|xargs kill -9
#cat /var/run/rsyncd.pid | xargs kill -9
pkill rsync
#再次启动
/usr/local/bin/rsync --daemon

服务器A

#安装rsync
cd /app/local
wget  http://rsync.samba.org/ftp/rsync/src/rsync-3.1.1.tar.gz
tar zxf rsync-3.1.1.tar.gz
cd rsync-3.1.1
./configure
make && make install

#安装inotify-tools
cd /app/local
wget http://github.com/downloads/rvoicilas/inotify-tools/inotify-tools-3.14.tar.gz
tar zxf inotify-tools-3.14.tar.gz
cd inotify-tools-3.14
./configure --prefix=/app/local/inotify 
make && make install

#安装sersync
cd /app/local
wget https://sersync.googlecode.com/files/sersync2.5.4_64bit_binary_stable_final.tar.gz
tar zxf sersync2.5.4_64bit_binary_stable_final.tar.gz
mv /app/local/GNU-Linux-x86/ /app/local/sersync
cd /app/local/sersync
#配置下密码文件，因为这个密码是要访问服务器B需要的密码和上面服务器B的密码必须一致
echo "rsync" > /app/local/sersync/user.pass
#修改权限
chmod 600 /app/local/sersync/user.pass
#修改confxml.conf
vi /app/local/sersync/confxml.xml


<?xml version="1.0" encoding="ISO-8859-1"?>
<head version="2.5">
 <host hostip="localhost" port="8008"></host>
 <debug start="true"/>
 <fileSystem xfs="false"/>
 <filter start="false">
 <exclude expression="(.*)\.php"></exclude>
 <exclude expression="^data/*"></exclude>
 </filter>
 <inotify>
 <delete start="true"/>
 <createFolder start="true"/>
 <createFile start="false"/>
 <closeWrite start="true"/>
 <moveFrom start="true"/>
 <moveTo start="true"/>
 <attrib start="false"/>
 <modify start="false"/>
 </inotify>
 
 <sersync>
 <localpath watch="/home/"> <!-- 这里填写服务器A要同步的文件夹路径-->
 <remote ip="8.8.8.8" name="rsync"/> <!-- 这里填写服务器B的IP地址和模块名-->
 <!--<remote ip="192.168.28.39" name="tongbu"/>-->
 <!--<remote ip="192.168.28.40" name="tongbu"/>-->
 </localpath>
 <rsync>
 <commonParams params="-artuz"/>
 <auth start="true" users="rsync" passwordfile="/app/local/sersync/user.pass"/> <!-- rsync+密码文件 这里填写服务器B的认证信息-->
 <userDefinedPort start="false" port="874"/><!-- port=874 -->
 <timeout start="false" time="100"/><!-- timeout=100 -->
 <ssh start="false"/>
 </rsync>
 <failLog path="/tmp/rsync_fail_log.sh" timeToExecute="60"/><!--default every 60mins execute once--><!-- 修改失败日志记录（可选）-->
 <crontab start="false" schedule="600"><!--600mins-->
 <crontabfilter start="false">
 <exclude expression="*.php"></exclude>
 <exclude expression="info/*"></exclude>
 </crontabfilter>
 </crontab>
 <plugin start="false" name="command"/>
 </sersync>
 
 <!-- 下面这些有关于插件你可以忽略了 -->
 <plugin name="command">
 <param prefix="/bin/sh" suffix="" ignoreError="true"/> <!--prefix /opt/tongbu/mmm.sh suffix-->
 <filter start="false">
 <include expression="(.*)\.php"/>
 <include expression="(.*)\.sh"/>
 </filter>
 </plugin>
 
 <plugin name="socket">
 <localpath watch="/home/demo">
 <deshost ip="210.36.158.xxx" port="8009"/>
 </localpath>
 </plugin>
 <plugin name="refreshCDN">
 <localpath watch="/data0/htdocs/cdn.markdream.com/site/">
 <cdninfo domainname="cdn.chinacache.com" port="80" username="xxxx" passwd="xxxx"/>
 <sendurl base="http://cdn.markdream.com/cms"/>
 <regexurl regex="false" match="cdn.markdream.com/site([/a-zA-Z0-9]*).cdn.markdream.com/images"/>
 </localpath>
 </plugin>
</head>

#运行sersync
nohup /app/local/sersync/sersync2 -r -d -o /app/local/sersync/confxml.xml >/app/local/sersync/rsync.log 2>&1 &
nohup /app/local/sersync/sersync2 -r -d -o /app/local/sersync/img.xml >/app/local/sersync/img.log 2>&1 &

-d:启用守护进程模式
-r:在监控前，将监控目录与远程主机用rsync命令推送一遍
-n: 指定开启守护线程的数量，默认为10个
-o:指定配置文件，默认使用confxml.xml文件

GitHub源码仓库

file://E:\sersync   (0 folders, 3 files, 1.88 MB, 1.88 MB in total.)
    inotify-tools-3.14.tar.gz 350.36 KB
    rsync-3.1.1.tar.gz    869.26 KB
    sersync2.5.4_64bit_binary_stable_final.tar.gz 710.24 KB

sersync - https://github.com/wsgzao/sersync

from https://wsgzao.github.io/post/sersync/

------------------------------------------------

rsync的使用

rsync是一个文件同步工具，rsync在同步的时候，只同步发生变化的文件或者目录（每次发生变化的数据相对整个同步目录数据来说是很小的，rsync在遍历查找比对文件时，速度很快），因此，效率很高。

rsync有两种工作模式，客户端和服务器端，即rsync的客户端和服务器端是同一个程序，名字都叫rsync，你用它启动了服务作为守护进程，它就是一个服务器端，你没启动服务，而是直接调用它的命令，那么它就是客户端。

方案讨论

假设有A、B两台服务器，我们要把A的文件同步到B，由于rsync的工作模式分为客户端从服务器端下载文件(pull操作)，或者客户端把文件推送到服务器端(push操作)，所以我们要讨论一个问题，A、B谁做客户端，谁做服务器端？

方案一：
假设A做服务器端，B做客户端，那么B要从A中同步文件，就要启动定时任务，每隔一段时间执行一次同步命令，该命令会把A中的变化数据同步过来(实际上是做rsync客户端做pull操作)。

方案二：
假设A做客户端，B做服务器端，A定时运行同步命令，把变化文件推送到B（rsync客户端做push操作）

这两个方案感觉都可以，那到底哪个好呢？
假设我们还有C、D两台服务器也要从A同步文件，也就是B、C和D都从A同步文件，假设用方案一，那么B、C和D都要设置一个定时任务，定时从A中拉取文件进行同步，但这有一个问题，无法实时同步，因为B、C和D都不知道A什么时候更新了文件，只能定时去同步。

如果使用方案二，则B、C和D都是rsync的服务器端(都要启动一个rsync守护进程)，而客户端只有一个，就是A。假如我们在A中添加定时任务，定时执行同步命令，把A中的文件推送到B、C和D，那感觉和方案一没什么区别，也是无法实时同步文件。

但是，在方案二中，我们可以利用sersync来检测哪些文件更新了，然后用sersync调用rsync的同步命令，把更新变化的文件推送到B、C、D服务器。
另外，还可以用git hooks，svn hooks，即所谓的钩子，即把A作为发布机，git/svn在上面更新文件后，可以“顺便”调用一下rsync同步命令，这样就能做到每次发布的时候“顺便”把文件也同步到B、C和D了。

所以我们现在清楚了，“发布机”要作为rsync的客户端，其它机器都作为rsync的服务器端，这样，每当“发布机”文件有变化，都可以“推(push)”到各个服务器中。

配置rsync服务器端

根据前面的分析，我们使用方案二，A作为客户端，B、C和D作为rsync服务器端，，由于是开虚拟机做实验，为了方便，我们把D去掉，只配置三台，因为B、C、D的配置是一样的，我们假设三台服务器分别为：
A：10.37.129.5(rsync客户端)
B：10.37.129.6(rsync服务器端)
C：10.37.129.7(rsync服务器端)

以下为服务器端配置，需要在B服务器和C服务器分别做一遍。

rsync是git的依赖，如果你用yum安装过git，那rsync肯定安装了，如果没安装你就先安装rsync：

sudo yum -y install rsync

如果已经安装过了，那你也可以更新一下：

sudo yum update rsync

用vim打开配置文件：

sudo vim /etc/rsyncd.conf

配置文件中已经有一个注释的example，可以把它删掉，把下面内容加到配置文件中：

#指定运行的用户名或ID号(rsync客户端推送过来的文件所有者会被创建为uid指定的所有者)
uid = www
#指定运行的组名或组ID号(rsync客户端推送过来的文件所属组会被创建为gid指定的所属组)
gid = www
#切换目录
use chroot = no
#最大连接数
max connections = 10
#pid文件路径
pid file = /var/run/rsyncd.pid
#锁文件路径
lock file = /var/run/rsyncd.lock
#日志文件路径（可通过log format参数设置日志格式）
log file = /var/run/rsyncd.log
#传输日志
transfer logging = yes
#超时时间
timeout = 900
#忽略无法读取的文件
ignore nonreadable = yes
#忽略部分io错误
ignore errors
#是否只读(false就接受上传，即puhs，否则只接受下载，即pull)
read only = false
#下载(pull)操作时，如果没写下载哪个模块，则会列出模块
list = false
#允许的客户端ip或ip段(24也可写成255.255.255.0，这是网段，或子网掩码)
host allow = 10.37.129.5/24
#除了允许的ip或ip段外禁止其他ip或ip段
host deny = 0.0.0.0/32 #也可以直接写*号
#认证用户（客户端执行同步操作时，需要用user@ip来指定用户名，就跟ssh登录一个道理，这里写users是因为可配置多个用户，用逗号隔开即可）
auth users = xiebruce
#认证密码文件(后面会创建该文件，其实内容就是“用户名:密码”，一行一个用户)
secrets file = /etc/rsyncd.secrets
#如果用-az指定了打包压缩同步的文件，则指定这些后缀可以不压缩这些文件。
# dont compress   = *.gz *.tgz *.zip *.z *.Z *.rpm *.deb *.bz2

############# 自定义的传输模块2 ##################
[wwwroot]
    #同步路径
    path = /data/wwwroot
    #注释
    comment = website
    #不接受的目录(该目录位于path指定的目录下)
    exclude = cache
############# 自定义的传输模块2 ##################
[wwwroot2]
    path = /data/wwwroot2
    comment = website
    exclude = cache

以上配置文件为我用到的配置，可能并没有把rsync的所有配置项都写在上面，如果你需要什么特殊设置，可以man rsync查看还有什么选项可用。

个别参数解释：
use chroot = no如果为yes, rsync会首先进行chroot设置，将根映射在path参数路径下，对客户端而言，系统的根就是path参数指定的路径。但这样做需要root权限，并且在同步符号连接资料时只会同步名称，不会同步内容，所以我们一般设置为no。

大部分参数都可写在模块里面，这样可以分别控制各模块的认证，允许ip等等，可查看：rsync文件同步详解。

A服务器创建用户登录服务器端的密码文件(里面的内容就是用于登录服务器端的密码)：

sudo echo "123456" > /etc/rsyncd.password

在B、C服务器创建用户密码对：

sudo echo "xiebruce:123456" > /etc/rsyncd.secrets

注意，服务器端的用户密码文件是“用户名:密码”，而客户端只需要密码，至于.secrets结束还是.password结束都无所谓，你不写后缀，或者你以abc结束都没问题，只要引用的时候用相同的名字引用就行，只是我们写成.secrets和.password方便自己知道这是个什么文件。

把A的服务器的密码文件权限设置为600：

sudo chmod 600 /etc/rsyncd.password
sudo chown root:root /etc/rsyncd.password

把B、C服务器的用户密码文件权限设置为600：

sudo chmod 600 /etc/rsyncd.secrets
sudo chown root:root /etc/rsyncd.secrets

注意一定要两边都设置，否则同步的时候无法使用(会提示密码文件不能具有其他权限)。
曾经被坑过，C机(同步目标机)的/etc/rsyncd.secrets的所有者和所属组不是root:root结果导致A机的lsyncd启动不了，因为无法连接B机，不要以为你在C机是用root启动rsyncd就没事，权限还是会有问题。

在B、C服务器上分别启动rsync的服务器端服务：

rsync --daemon

但一般我们不会用上面那种启动方法，而是用systemctl来启动：

systemctl start rsyncd

设置开机自启动：

systemctl enable rsyncd

三台服务器都要允许873端口，如果是虚拟机做实验，可直接关闭防火墙：
centos7默认防火墙：

systemctl stop firewalld

关闭iptable防火墙：

chkconfig iptables off && service iptables stop

rsync客户端

rsync客户端执行以下命令即可A中变化的文件同步到B服务器（C服务器同理，把ip改一下即可）：

 rsync -avz --partial --delete /data/wwwroot xiebruce@10.37.129.6::wwwroot/ --password-file=/etc/rsyncd.password

该命令意思是把/data/wwwroot目录的数据，同步到10.37.129.6服务器的wwwroot模块下（至于该模块是对应哪个目录，rsyncd.config里有指定）。
xiebruce是认证用户名（对应服务器的auth users指定的用户名的其中一个用户名即可）
--partial是指不要删除那些“由于各种原因只传了一部分(即没传完)的文件”，以便后面重新开始传输时，继续传输剩下未传的部分，其实也就是我们所说的“断点续传”，所以--partial选项必须要加上，如果有单个文件上百M，你也不希望传了80多M后断了，然后重新传吧？
--delete表示删除只存在于rsync服务器端(这里指B服务器)的文件（也就是客户端没有而服务端有的文件，不想删除就不要指定该选项）。
--password-file指定密码文件，否则需要手动输入。
-avz这是多个选项
-a指archive，意为归档，打包（注意打包是打包，并不是压缩，打包只是把多个文件打包成一个文件）。
-v指verbose，在各种linux命令中都是很常见选项，指输出详情。
-z指compress，即压缩后再传输（这才是压缩，前面的-a是打包）

rsync配置好了，手动同步也正常了，但是我们总不可能每次更新了文件，都登录到服务器执行一下这条命令吧？这太麻烦了，于是有人想，创建一个crontab定时任务，每隔5分钟或10分钟同步一次不就行了？是的，这样确实可以，但这样做的缺点有两个：
1. 无法实时同步，必须等10分钟，对于紧急修复bug的更新也无法及时同步。
2. 每次同步rsync都需要扫描整个目录有哪些文件变化了(因为变化的文件才会同步)，如果文件数量多达上百万文件的话(对于一些框架，这个文件数量并不奇怪，比如node_modules目录)，但有时候文件可能只有一个文件变化了而已，所以这样无意义的扫描只是在做无用功，增加服务器的负担。

还好，sersync可以帮我们解决rsync扫描文件过多的问题。

sersync的使用

sersync是国人写的一个软件，可以记录下被监听目录中发生变化的（包括增加、删除、修改）具体某一个文件或某一个目录的名字。
github：https://github.com/wsgzao/sersync
官方博客，因为是个人写的，所以也就是一个个人博客，并没什么详细的说明：https://wsgzao.github.io/post/sersync/

Inotify是一个Linux内核特性，它监控文件系统，并且及时向专门的应用程序发出相关的事件警告，比如删除、读、写和卸载操作等。您还可以跟踪活动的源头和目标等细节，sersync正是通过Inotify这个Linux系统特性来工作的。

sersync与rsync配合，可以减少rsync扫描文件的数量(因为rsync只同步变化的文件，而要知道哪些文件发生了变化，需要每个文件都扫描一遍才知道)，而sersync可以在文件变化的时候就检测出来哪个文件或者说哪几个文件发生了变化，而不需要把所有文件都扫描一遍，所以sersync的存在，就是用检测哪个文件变化了，然后自动拼接一个rsync命令并执行一次同步(当然它还有附加功能)。

在sersync之前，有一个叫Inotify-tools的工具，也是基于系统的inotify的，但是Inotify-tools只能监控指定的目录是否发生变化，进而自动执行事先编写好的rsync同步命令，至于要同步哪些文件，Inotify-tools没有告诉rsync，rsync只能自己去扫描，所以这跟定时同步其实没有太大区别，只是比定时同步更加实时而已，但还是无法解决rsync扫描文件做无用功的问题，因为我前面也说了，有可能只是一个文件发生了变化而已，有可能只是加了个英文句点而已，如果说加一个句点导致rsync去扫描100万个文件就是为了找出哪个文件增加了一个句点，那这也太浪费资源了，做的都是无用功。

使用sersync

根据前面所说，我们需要在在A服务器上安装sersync，当文件变化时，sersync变会自动拼接一个rsync命令并执行，从而完成文件同步。sersync减少rsync扫描的原理，是用rsync的--include参数直接告诉rysnc要同步哪些文件，从而rsync只会扫描这些指定的文件，而不会扫描整个同步目录。

下载sersync：sersync2.5.4_64bit_binary_stable_final.tar.gz

sersync无需编译，解压出来是一个GNU-Linux-x86的目录(另担心x86，64位服务器一样可执行)，里面有两个文件，一个是sersync2可执行文件，另一个是配置文件：

GNU-Linux-x86
|-- confxml.xml
`-- sersync2

虽然不用安装，但按统一规则，自己编译或安装的软件都放到/usr/local目录下，创建目录：

sudo mkdir /usr/local/sersync

然后把GNU-Linux-x86目录下的两个文件(不包括目录本身)移动到/usr/local/sersync目录中，目录结构如下：

/usr/local/sersync
├── confxml.xml
└── sersync2

创建软链接，把sersync2加入到环境变量中：

ln -s /usr/local/sersync/sersync2 /usr/local/bin/sersync2

配置文件我把所有选项都加上了解释，由于配置文件较长，需要花点时间把所有选项以及注释看一遍，你会发现其实并没有什么难的：


<head version="2.5">
    
    <host hostip="localhost" port="8008"></host>

    
    <debug start="false"/>

    
    <fileSystem xfs="true"/>

    
    <filter start="true">
        
        
        
        
        <exclude expression="^cache/*"></exclude>
    </filter>

    
    <inotify>
        
        <delete start="true"/>
        
        <createFolder start="true"/>
        
        <createFile start="false"/>
        
        <closeWrite start="true"/>
        
        <moveFrom start="true"/>
        
        <moveTo start="true"/>
        
        <attrib start="false"/>
        
        <modify start="false"/>
    </inotify>

    
    <sersync>
        
        <localpath watch="/data/wwwroot">
            
            <remote ip="10.37.129.6" name="wwwroot"/>
            
            <remote ip="10.37.129.7" name="wwwroot2"/>
            
        </localpath>

        
        <rsync>
            
            <commonParams params="-azP"/>
            
            <auth start="true" users="xiebruce" passwordfile="/etc/rsyncd.password"/>
            
            <userDefinedPort start="false" port="873"/>
            
            <timeout start="false" time="100"/>
            
            <ssh start="false"/>
        </rsync>
        
        <failLog path="/tmp/rsync_fail_log.sh" timeToExecute="60"/>

        
        <crontab start="false" schedule="600">
            
            <crontabfilter start="false">
                <exclude expression="*.php"></exclude>
                <exclude expression="info/*"></exclude>
            </crontabfilter>
        </crontab>
        
        <plugin start="false" name="command"/>
    </sersync>

    
    <plugin name="command">
        
        <param prefix="/bin/sh" suffix="" ignoreError="true"/>  
        
        <filter start="false">
            <include expression="(.*)\.php"/>
            <include expression="(.*)\.sh"/>
        </filter>
    </plugin>

    
    <plugin name="socket">
        <localpath watch="/data/wwwroot">
            <deshost ip="192.168.138.20" port="8009"/>
        </localpath>
    </plugin>

    
    <plugin name="refreshCDN">
        <localpath watch="/data0/htdocs/cms.xoyo.com/site/">
            <cdninfo domainname="ccms.chinacache.com" port="80" username="xxxx" passwd="xxxx"/>
            <sendurl base="http://pic.xoyo.com/cms"/>
            <regexurl regex="false" match="cms.xoyo.com/site([/a-zA-Z0-9]*).xoyo.com/images"/>
        </localpath>
    </plugin>
</head>

启动sersync服务：

sersync2 -o /usr/local/sersync/confxml.xml -d

启动后会给出一些提示。

现在，你可以测试一下在A服务器的同步目录上添加文件，修改文件内容，看B，C服务器是否会修改？我这里是成功的。

实例解释一下配置文件里的这一句：

 <failLog path="/tmp/rsync_fail_log.sh" timeToExecute="60"/>

前面配置文件里的注释也说了，由于各种原因(如网络很差或延迟非常大)可能会有传输失败的情况，那为什么记录传输失败的文件不叫.log，而叫.sh呢？

下图就是我传输失败后自动生成的/tmp/rsync_fail_log.sh文件的内容。

前面说过，sersync只是检测有哪些文件变化了，最终它还是会组装出rsync的同步命令，上图就是它组装的同步命令执行失败后，被保存到/tmp/rsync_fail_log.sh文件中，并且每隔timeToExecute分钟执行一次（注意这个单位是min）。

如果你遇到这种失败的语句，你可以复制出来自己手动执行一下，看出来什么问题（如果选项没有-v那你就加上-v）。

另外，这一句是指定是否开启xfs格式，如果你的文件系统是xfs格式，那就要设置为true，否则设置为false：

<fileSystem xfs="true"/>

我们可以执行df -Th来查看文件系统是什么格式，通常来说linux有两种文件系统，一种是以前用的ext4，一种是新的xfs。

以下是sersync的一些选项解释：
1.查看帮助：

./sersync2 -h

2.启动sersync，-d:daemon，表示以守护进程方式启动，不指定配置文件，则默认会在当前目录下查找名为confxml.xml的配置文件：

./sersync2 -d

3.在开启实时监控的之前对主服务器目录与远程目标机目录进行一次整体同步：

./sersync2 -r

如果需要将sersync运行前，已经存在的所有文件或目录全部同步到远程，要以-r参数运行sersync，将本地与远程整体同步一次。如果设置了过滤器，即在xml文件中，filter为true，则暂时不能使用-r参数进行整体同步。-r参数将会无效。

4.指定配置文件，如果不指定，则默认查找当前目录下的confxml.xml文件：

./sersync2 -o XXXX.xml

5.指定线程数，例如./sersync -n 5指定线程总数为5，如果不指定，默认启动线程池数量是10，如果cpu使用过高，可以通过这个参数调低，如果机器配置较高，也可以适当把该参数调高：

./sersync2 -n num

6.不进行同步，只运行插件(如果不知道什么是插件，请认真看配置文件的注释)

./sersync2 -m pluginName

例如./sersync -m command，则在监控到文件事件后，不对远程目标服务器进行同步，而是直接运行command插件。

7.多个参数可以配合使用

./sersync2 -n 8 -o abc.xml -r -d

表示，设置线程池工作线程为8个，指定abc.xml作为配置文件，在实时监控前作一次整体同步，以守护进程方式在后台运行。

8.通常情况下，先手动执行一遍rsync整体同步，然后再开启sersync。

其实sersync好久不更新了，现在都用lsyncd了。

本文参考：
1. https://www.cnblogs.com/regit/p/8074221.html
2. http://blog.51cto.com/liubao0312/1677586
3. http://www.codesky.net/article/201207/171024.html

---------------------------------------------------------------

部署lsyncd+rsync实现服务器文件实时同步

简述如何同步

假设有A和B两台机，A同步到B，则：
A：安装lsyncd+rsync，并运行lsyncd服务；
B：只需要安装rsync，并运行rsyncd服务；

A中的lsyncd监听到文件变化后，调用A中的rsync向B推送文件，B因为运行有一个rsyncd服务，所以可以接收这个推送，从而完成文件的同步。

另外还可以有C、D、E、F、……，它们都与B相同，只要运行rsyncd服务即可，A上可配置一次性推送向多台机器。

Lsyncd是什么？

Github：axkibe/lsyncd
官方文档：Lsyncd – Live Syncing (Mirror) Daemon

Lsyncd是一个辅助文件同步工具。它通过监听系统的文件变化事件，调用rsync进行同步。注意“辅助”二字，辅助的意思是：同步文件本身并不是由lsyncd来实现，它只负责监测哪些文件改变了，进而调用rsync来完成同步，真正同步文件的是rsync.

Lsyncd的三种同步模式

default.rsync
default.rsyncssh
default.direct

为了方便，我们直接把它们称为rsync、rsyncssh、direct。

1. rsync同步模式
首先，你需要知道rsync的基本用法，以下的rsync命令就可以把文件从本地的“/data/wwwroot”目录推送到远程的“xiebruce@10.37.129.6::wwwroot/”目录中，运行在“rsync同步模式”的lsyncd正是通过组装类似这样的命令来同步文件的：

 rsync -avz --partial --delete /data/wwwroot xiebruce@10.37.129.6::wwwroot/ --password-file=/etc/rsyncd.password

有人可能会疑惑，既然rsync本身就可以同步，那要lsyncd干嘛？有两个原因：
1. 实时同步。
2. 减少rsync扫描文件带来的延时和性能损耗。

直接使用rsync是可以同步没错，但是它却无法知道“什么时候同步”，因为rsync只有执行同步命令的时候，才会去扫描文件判断哪些文件被修改了，但什么时候要执行同步命令呢？rsync没有这功能，某个文件修改了，rsync并不会获得通知说某个文件已经修改了，直接使用rsync，只能建立一个定时任务，每隔一定的时间（比如5分钟，10分钟等等）去执行一次同步，这样虽然能同步，但却“不实时”了。

而lsyncd就可以监听文件的修改，换句话说，某个文件修改了，lsyncd会得到通知(原理是使用linux系统的inotify/fsevents功能)，得到通知之后，再去调用rsync把修改的文件进行同步(即组装一句rsync同步语句并执行)，达到“实时同步”的效果。

lsyncd调用rsync同步命令的时候，会用rsync的--include-from=FILE之类的选项来指定要同步哪些文件，这样可以达到“减少rsync扫描文件带来的延时和性能损耗”。

为什么这么说呢？因为如果让rsync自己去查询哪些文件改变了，需要消耗较多的时间和服务器资源，试想一下，在100万个文件中，有一个文件添加了一个英文的句号.，如果没有lsyncd告诉rsync改变的是这个文件，那rsync就要去扫描100万个文件来找出这个仅仅多了一个.的文件，虽然rsync的查找效率很高，但这个查找是非常没有必要的，这就是为什么lsyncd能“减少rsync扫描文件带来的延时和性能损耗”。

2. rsyncssh同步模式
明白了rsync同步模式，就不难明白rsyncssh模式，因为rsync本身就是有ssh模式的，lsyncd同样是负责监听哪些文件变化了，然后组装rsync同步命令进行同步。

rsync的ssh模式，主要的好处是用于文件移动的时候。假设我现在有两台机A和B，A中的test目录文件变化会自动同步到B中的test目录，现在A、B的test目录文件如下：

├── dir1
│   ├── aa.txt
│   ├── bb.txt
│   └── cc.txt
└── dir2
    └── dd.txt

假设现在把A机的bb.txt和cc.txt从dir1移动到dir2，即变成如下所示的状态：

├── dir1
│   └── aa.txt
└── dir2
    ├── bb.txt
    ├── cc.txt
    └── dd.txt

假设使用普通的rsync模式，那么rsync会先删除B机中的dir1中的bb.txt和cc.txt，并把A机中的bb.txt和cc.txt文件上传到B机中的dir2目录，达到同步的效果。

但如果你rsync运行在ssh模式，那么它会直接在B机中把dir1中的bb.txt和cc.txt用mv命令直接移动到dir2目录，A机没有向B机传任何数据，效率显而易见(特别是移动的数据特别多的时候更明显)。

这样看，rsyncssh模式应该是最好的，但它却有一个缺点，就是同步进程只能是单进程(maxProcesses=1)，而rsync模式是可以多进程同步的(速度快)。

3. direct同步模式
这个模式用于本地的两个目录之间同步，不用于远程服务器同步。lsyncd同样是监听文件变化事件，然后把变化的文件从源目录同步到目标目录，同步的命令，就是linux系统本身的命令，比如cp、rm、mv，增加了文件用cp拷过去，删除了文件，那边也用rm删除，移动了文件，那边也用mv移动。

安装lsyncd

CentOS用yum、其他的用各自的包管理软件，比如Ubuntu用apt-get，Mac用brew install等等：

yum -y install lsyncd

因为必须用到rsync，所以我们也要安装rsync(rsync是git的依赖，如果你服务器安装过git那肯定就已经有rsync了，但不管有没有都可以执行一下下边这条命令，因为它不止可以安装，还可以更新rsync)：

yum -y install rsync

Lsyncd安装好之后，默认的配置文件在/etc/lsyncd.conf，另外还有些配置的例子在/usr/share/doc/lsyncd-2.2.2/examples下：

├── lalarm.lua
├── lbash.lua
├── lecho.lua
├── lftp.lua
├── lgforce.lua
├── limagemagic.lua
├── lpostcmd.lua
├── lrsync.lua
├── lrsyncssh.lua
└── lsayirc.lua

实际上/etc/lsyncd.conf也可以写成/etc/lsyncd.lua，因为它本身就是用lua(一种脚本语言)写配置的，所以，在配置里写注释的时候，要使用lua语言的注释符号，即两个横杠--。

Lsyncd配置文件详解

前面说过了，配置文件是使用lua语言写的，所以注释要用lua语言的注释符号，即两个横杠--。

配置文件主要有三部分：

settings：lsyncd本身的一些设置，比如日志文件路径，同步进程数，是否后台运行等等。
sync：同步相关的设置，比如从哪同步到哪，要忽略哪些文件，多久同步一次等等
rsync：这部分是在sync里面的，它主要配置rsync本身的一些选项。

以下是两个官方的配置文档：

配置Settings：The Configuration File
配置sync和rsync：Config Layer 4: Default Config

/etc/lsyncd.conf中的默认内容没什么价值，可以全部删除，下边我们来讲解配置文件要怎么写。

default.rsync模式配置文件：

-- 由于该配置文件实际上是lua语言的语法，所以写注释要用--，--是lua语言的注释符号
-- Lsyncd本身的配置
settings {
    -- 指定日志文件位置
    logfile = "/var/log/lsyncd/lsyncd.log",

    -- 指定状态文件位置
    statusFile = "/var/log/lsyncd/lsyncd.status",

    -- inotify事件模式，什么事件才同步，CloseWrite表示文件关闭的时候同步(创建文件，修改文件后保存都会触发CloseWrite事件)
    inotifyMode = "CloseWrite",

    -- 最大同步进程数(default.rsyncssh模式，则必须设置为1，这就是rsyncssh模式的缺点了，如果是default.rsync模式则可以设置大于1，这样会有多个同步进程，速度更快)
    maxProcesses = 8,
    -- maxProcesses = 1,

    -- 配合下面的delay选项使用，delay单位是秒，当delay时间到了，不管maxDelays设置多少，都会同步，同样，当maxDelays达到了设定值，不管是否到delay时间，都会同步，即两个选项有一个满足即会触发同步，为了实时同>步，我们一般设置为1，表示即使只有一个文件改变也同步
    maxDelays = 1,

    -- 是否以后台的方式运行，注意它是nodaemon，所以是双重否定，如果填false，意思就是“不要不后台运行”(即后台运行)，非后台运行一般用于调试，把rsync的verbose也设置为true，这样会把同步的细节输出到控制台，方便调试
    nodaemon = false,
}

---- 同步配置default.rsync模式(比如配置从哪同步到哪，要忽略哪些文件，多久同步一次等)，可以有多个sync模块，每个模块用于设置一台目标机器
sync {
    -- 有default.rsync/default.direct/default.rsyncssh三种模式，我们默认都用default.rsync即可。
    default.rsync,

    -- 同步源目录(本机某个目录)
    source = "/data/wwwroot",

    -- 同步目标地址，不同同步模式有不同写法，由于绝大多数情况都采用rsync同步，所以这里写的是rsync的同步地址
    target = "xiebruce@10.37.129.7::wwwroot",

    -- 默认true，允许删除目录服务器中的某些文件(即删除“那些在源服务器中不存在的文件”)，可选值有: true/false/startup/running，startup就是只在启动lsyncd服务的时候判断目标服务器中有哪些文件在源服务器中没有，然后把这些文件删除，但启动之后如果目标服务器又新增了文件，这些文件即使在源服务器不存在，也不会被删除；而running与startup正好相反，是在启动的时候不会删除，启动之后会删除，true=running+startup，false相当于running和startup都不做。
    -- delete = true,

    -- 哪些文件不同步(可用正则))
    exclude = {
        '.**',
        '.git/**',
        '*.bak',
        '*.tmp',
       'runtime/**',
       'cache/**'
    },

    -- 与上边的maxDelays配合，maxDelays是累计事件数(单位：个)，delay是时间(单位：秒)，这两个只要有一个符合条件就会同步一次，但为了确保实时同步，maxDelays我们一般设置为1，也就是只要有一个文件变化事件，就会同步一次，而delay是比较大的，默认是15。当然，假如我们把maxDelays设置为100，那可能15秒到了也没有达到100个文件变化，但由于到达时间了，它也会同步。
    delay = 15,

    -- 当init = false时只同步进程启动以后发生改动事件的文件，原有的目录即使有差异也不会同步，如果为true，则启动后如果源目录与目标目录的文件有差异，就会同步，我们当然要设置为true，默认为true，所以这个设置可以不写，写在这里是为了解释它。
    -- init = false,

    -- rsync的配置（这是default.rsync模式，如果是default.rsyncssh模式，该模块的配置会有所不同）
    rsync = {
        -- rsync可执行文件的绝对路径
        binary = "/usr/bin/rsync",

        -- 密码文件路径(default.rsyncssh模式不需要该项)
        password_file = "/etc/rsyncd.password",

        -- 打包后再同步(注意，打包不等于压缩，打包即可以压缩也可以不压缩)
        archive = true,

        -- 压缩后再同步
        compress = false,

        -- 输出同步信息(由于是后台执行，所以没必要输出，如果非后台执行可以设置为true，非后台执行主要用于调试)
        verbose  = false,

        -- 由于rsync有非常多的选项(请自己rsync --help查看)，部分非主要选项可以用_extra的方式指定，双引号引住，逗号分隔(bwlimit中的bw是bandwith，即带宽，整个意思是带宽限制，omit-link-times忽略符号链接的修改时间)
        _extra = {"--bwlimit=200", "--omit-link-times"}
    }
}

解释几个选项：

target = “xiebruce@10.37.129.6::wwwroot”，为什么这么写？因为这是rsync的同步地址格式，10.37.129.6是rsync服务器端的ip，xiebruce是服务器端配置的用户名，wwwroot是服务器端的模块名，具体请查看：rsync的使用。
password_file = “/etc/rsyncd.password”，rsyncd.password中的内容到底是什么？其实非常简单，就是一个字符串(比如：123456，你也不用写password=123456，就直接写123456即可)，是服务器端的密码(rsync服务器端可以配置账号和密码)，文件名不是说非得.password结尾，因为这就是文本文件，有后缀，没后缀，后缀名是什么都无所谓，整个文件名是什么也无所谓，只要你在配置文件里使用的时候，把绝对路径放进去即可。

exclude再可以用excludeFrom来代替，这样就可以在外部文件单独写要排除同步的文件：

excludeFrom = "/etc/lsyncd_exclude.lst",

外部排除同步文件/etc/lsyncd_exclude.lst的写法：

.svn
Runtime/*
Uploads/*

若某个事件的路径中的某些片段匹配这些文本，那么排除。比如/bin/foo/bar匹配规则foo。
– 如果规则以/开始，那么只匹配路径的开始
如果规则以/结束，那么只匹配路径的结束
– ? 匹配任何不是/的字符
– *匹配0或多次非/字符
– **匹配任何字符0或多次。

rsync服务器端配置

文章开头已经说过A、B两台机各自要安装什么，现在A机的操作前面已经讲过了，B机的操作，由于之前写过文章，这里就不再重复，请直接看：rsync的使用。

开放端口

rsync的默认端口是873，如果你是CentOS7的firewalld防火墙，可以用以下方法允许873端口：

firewall-cmd --zone=public --add-port=873/tcp --permanent
firewall-cmd --reload

如果你是本地做实验觉得防火墙麻烦，也可关闭防火墙：

systemctl stop firewalld

启动lsync服务

如何启动的官方文档：Invoking。

lsync配置文件写好后，就可以启动它了，由于我们有配置文件，所以启动方式是：

lsyncd -log Exec /etc/lsyncd.conf

-log Exec表示记录所有进程的日志(因为如果maxProcesses大于1就会有多个同步进程)

启动后，它只输出了：

21:46:54 Normal: --- Startup, daemonizing ---

查看是否启动成功：

ps aux | grep lsyncd

如何进程正常运行，可以看到：

root      5238  7.7  0.6  13348  3340 ?        Ss   21:46   0:15 lsyncd /etc/lsyncd.conf

查看log文件，你会看到已经同步了很多文件：

vim /var/log/lsyncd/lsyncd.log

但其实在CentOS7系统中，我们一般不直接启动，而是用systemctl命令来启动：

systemctl start lsyncd

查看启动状态：

systemctl status lsyncd

停止：

systemctl stop lsyncd

重启：

systemctl restart lsyncd

设置开机自启动：

systemctl enable lsyncd

default.rsyncssh模式配置文件：
相比rsync，主要修改的有以下几点：

settings中的maxProcesses必须为1，否则无法启动，并报以下错误：

Error: error preparing /etc/lsyncd.conf: /etc/lsyncd.conf:69: default.rsyncssh must have maxProcesses set to 1.

rsync中的password_file去掉(或注释掉)，因为ssh已经不需要用rsync的password来验证了。
sync添加一个host，格式就是ssh登录的格式(即：username@12.34.56.78这样的格式)
把target改成targetdir，值的格式就是目标服务器的绝对地址，比如：/data/wwwroot/(最后一个斜杠可要可不要，最好要，因为这样一看就知道是目录)。
host指定的ssh登录用户需要具有targetdir指定的目录的权限，如果启动不了请尝试用root，并且设置该用户免密登录：Linux-使用ssh免密码登录，不配置免密码登录将会无法启动。
免密码登录需要注意：假设你A机使用root启动lsyncd(其实基本上都得用root)，而你host=zhangsan@12.34.56.78(B机)，那么你必须保证A机能在root用户下ssh zhangsan@12.34.56.78能无密码登录，因为很可能你A机有个用户叫lisi，并且你在“lisi”用户下能免密登录“ssh zhangsan@12.34.56.78”，而在root用户下不能免密登录“ssh zhangsan@12.34.56.78”，那么你一样无法启动，原因是你是在root用户下启动的，你就必须让root能免密登录B机。
host指定ssh用户，必须与目标文件夹需要的用户相同，比如很多时候，wwwroot网站目录我们都使用www:www这样的用户和组，所以你就必须用这个用户来同步，否则同步后创建出来的文件并不是这个权限，权限不对则网站可能会出问题。

-- 由于该配置文件实际上是lua语言的语法，所以写注释要用--，--是lua语言的注释符号
-- Lsyncd本身的配置
settings {
    -- 指定日志文件位置
    logfile = "/var/log/lsyncd/lsyncd.log",

    -- 指定状态文件位置
    statusFile = "/var/log/lsyncd/lsyncd.status",

    -- inotify事件模式，什么事件才同步，CloseWrite表示文件关闭的时候同步(创建文件，修改文件后再关闭(如vim的:wq)都会触发CloseWrite事件)
    inotifyMode = "CloseWrite",

    -- 最大同步进程数(default.rsyncssh模式必须设置为1，否则无法启动，default.rsync模式可以设置大于1)
    maxProcesses = 1,

    -- 配合下面的delay选项使用，delay单位是秒，当delay时间到了，不管maxDelays设置多少，都会同步，同样，当maxDelays达到了设定值，不管是否到delay时间，都会同步，即两个选项有一个满足即会触发同步，为了实时同>步，我们一般设置为1，表示即使只有一个文件改变也同步
    maxDelays = 1,

    -- 是否以后台的方式运行，注意它是nodaemon，所以是双重否定，如果填false，意思就是“不要不后台运行”(即后台运行)，非后台运行一般用于调试，把rsync的verbose也设置为true，这样会把同步的细节输出到控制台，方便调试
    nodaemon = false,
}

-- 同步配置default.rsync模式(比如配置从哪同步到哪，要忽略哪些文件，多久同步一次等)，可以有多个sync模块，每个模块用于设置一台目标机器
sync {
    -- 有default.rsync/default.direct/default.rsyncssh三种模式，我们默认都用default.rsyncssh方式，因为这种方式其实是最好的。
    default.rsyncssh,

    -- 同步源目录(本机某个目录)
    source = "/data/wwwroot/",

    -- 同步目标地址，rsync模式写法
    -- target = "xiebruce@10.37.129.6::wwwroot",

    -- 同步目标地址，rsyncssh模式写法
    host="10.37.129.6",
    targetdir="/data/wwwroot/",

    -- 默认true，允许删除目录服务器中的某些文件(即删除“那些在源服务器中不存在的文件”)，可选值有: true/false/startup/running，startup就是只在启动lsyncd服务的时候判断目标服务器中有哪些文件在源服务器中没有，然后把这些文件删除，但启动之后如果目标服务器又新增了文件，这些文件即使在源服务器不存在，也不会被删除；而running与startup正好相反，是在启动的时候不会删除，启动之后会删除，true=running+startup，false相当于running和startup都不做。
    -- delete = true,

    -- 哪些文件不同步(可用正则))
    exclude = {
        '.**',
        '.git/**',
        '*.bak',
        '*.tmp',
       'runtime/**',
       'cache/**'
    },
    -- 忽略文件路径规则也可用外部配置文件
    -- excludeFrom = "/etc/lsyncd_exclude.lst",

    -- 与上边的maxDelays配合，maxDelays是累计事件数(单位：个)，delay是时间(单位：秒)，这两个只要有一个符合条件就会同步一次，但为了确保实时同步，maxDelays我们一般设置为1，也就是只要有一个文件变化事件，就会同步一次，而delay是比较大的，默认是15。当然，假如我们把maxDelays设置为100，那可能15秒到了也没有达到100个文件变化，但由于到达时间了，它也会同步。
    delay = 15,

    -- 当init = false时只同步进程启动以后发生改动事件的文件，原有的目录即使有差异也不会同步，如果为true，则启动后如果源目录与目标目录的文件有差异，就会同步，我们当然要设置为true，默认为true，所以这个设置可以不写，写在这里是为了解释它。
    -- init = false,

    -- rsyncssh的配置（这是default.rsyncssh模式，如果是default.rsyncssh模式，该模块的配置会有所不同）
    rsync = {
        -- rsync可执行文件的绝对路径
        binary = "/usr/bin/rsync",

        -- 密码文件路径(rsync模式不用该配置，rsyncssh模式才需要该项)
        -- password_file = "/etc/rsyncd.password",

        -- 打包后再同步(注意，打包不等于压缩，打包即可以压缩也可以不压缩)
        archive = true,

        -- 压缩后再同步
        compress = true,

        -- 同步符号链接文件
        copy_links = true,

        -- 同步符号链接目录
        copy_dirlinks = true,

        -- 输出同步信息(由于是后台执行，所以没必要输出，如果非后台执行可以设置为true，非后台执行主要用于调试)
        verbose  = false,

        -- 由于rsync有非常多的选项(请自己rsync --help查看)，部分非主要选项可以用_extra的方式指定，双引号引住，逗号分隔(bwlimit中的bw是bandwith，即带宽，整个意思是带宽限制，omit-link-times忽略符号链接的修改时间)
        _extra = {"--bwlimit=200", "--omit-link-times"},

        -- 指定ssh相关参数选项
        rsh = "/usr/bin/ssh -l xiebruce -i /root/.ssh/id_rsa -o StrictHostKeyChecking=no"
    }
}

其中这一句就是用来通过ssh登录到服务器的：

rsh = "/usr/bin/ssh -l xiebruce -i /root/.ssh/id_rsa -o StrictHostKeyChecking=no"

你平时使用ssh登录服务器，也许用的是ssh zhangsan@10.37.129.6，最多再加个-p指定一下端口，但其实ssh还有很多选项，比如ssh -l xiebruce root@10.37.129.6就表示，我虽然是用root去登录，但用-l(login的缩写)指定了登录的用户，所以最终会以xiebruce用户进行登录，而-i(identify的缩写)则表示指定私钥(身份认证文件)，通常是为了免密码登录服务器，原因很简单，这个同步不可能每次让你输入密码，所以需要免密码登录。

而-o(option的缩写)表示选项，ssh有很多选项，可以用man ssh查到，而每个选项是什么意思需要用man ssh_config来查看，“StrictHostKeyChecking”表示严格检查主机的key fingerprint(指纹密钥)，当你首次登录一台服务器的时候，它总会有这个提示：

The authenticity of host '10.37.129.7 (10.37.129.7)' can't be established.
ECDSA key fingerprint is SHA256:xcDUp3zNlJvhY4fwfwDH1pgOyc5p8Vsr2OjopanEQBw.
Are you sure you want to continue connecting (yes/no)?

如果你输入no那就不会登录，如果你输入yes，就会登录，并且把这个“key fingerprint”(指纹密钥)添加到你终端的ssh配置目录下的known_hosts文件中，这个文件的位置，对于Mac/Linux电脑，是在~/.ssh/known_hosts，Windows的话则是在C:\Users\用户名\目录下。

同理，现在是rsync登录你的ssh，所以rsync也会存储这样的指纹密钥，如果“StrictHostKeyChecking”设置为yes，就意味着每次都要严格检查密钥(就相当于你用终端登录时，每次都要你输入一遍yes)，这样显然是没必要的，所以我们要把它设置为“StrictHostKeyChecking=no”。

default.direct模式：该模式我没有测试

sync {
    default.direct,
    source  = "/home/user/src/",
    target  = "/home/user/trg/"
}

同时同步到多台机

格式如下，每台目标服务器一个sync模块即可，每个sync模块都像上边说的那样写就行，其实就只是ip不同，其他都一样：

-- Lsyncd本身的配置
settings {

}

--  B服务器配置
sync {

}

--  C服务器配置
sync {

}

--  D服务器配置
sync {

}

Total Pageviews