http://www.cnblogs.com/lei1016cn/archive/2010/10/21/1857761.html

更改源

vi /etc/apt/source.list

全部删除，加入下面的源。

### Security Sourcelist

deb http://security.ubuntu.com/ubuntu maverick-security main restricted
deb-src http://security.ubuntu.com/ubuntu maverick-security main restricted
deb http://security.ubuntu.com/ubuntu maverick-security universe
deb-src http://security.ubuntu.com/ubuntu maverick-security universe
deb http://security.ubuntu.com/ubuntu maverick-security multiverse
deb-src http://security.ubuntu.com/ubuntu maverick-security multiverse

### 163.com Sourcelist
deb http://mirrors.163.com/ubuntu/ maverick main universe restricted multiverse
deb-src http://mirrors.163.com/ubuntu/ maverick main universe restricted multiverse
deb http://mirrors.163.com/ubuntu/ maverick-security universe main multiverse restricted
deb-src http://mirrors.163.com/ubuntu/ maverick-security universe main multiverse restricted
deb http://mirrors.163.com/ubuntu/ maverick-updates universe main multiverse restricted
deb http://mirrors.163.com/ubuntu/ maverick-proposed universe main multiverse restricted
deb-src http://mirrors.163.com/ubuntu/ maverick-proposed universe main multiverse restricted
deb http://mirrors.163.com/ubuntu/ maverick-backports universe main multiverse restricted
deb-src http://mirrors.163.com/ubuntu/ maverick-backports universe main multiverse restricted
deb-src http://mirrors.163.com/ubuntu/ maverick-updates universe main multiverse restricted

上面部分是保留Ubuntu官方紧急安全补丁源。保存后，执行

sudo apt-get update
sudo apt-get upgrade

安装Nginx

apt-get install nginx

安装Mysql-server

apt-get install mysql-server

安装php,php-fpm,php常用模块

apt-get install php5-cgi php5-mysql php5-fpm php5-curl php5-gd php5-idn php-pear php5-imagick php5-imap php5-mcrypt php5-memcache php5-mhash php5-snmp php5-sqlite php5-tidy php5-xmlrpc php5-xsl php5-ming php5-pspell php5-recode

就这样，把Nginx,mysql,php都安装好了，安装好后都是启动了的，手动启动或者停止服务用下面的命令。

service nginx start     #启动nginx
service nginx restart   #重启nginx
service nginx stop      #停止nginx

service php5-fpm start    #启动php5-fpm
service php5-fpm restart  #重启php5-fpm
service php5-fpm reload   #重加载php5-fpm
service php5-fpm stop     #停止php5-fpm

service mysql start       #启动mysql
service mysql restart     #重启mysql
service mysql stop        #停止mysql

安装好了，还需要做一些优化配置。
nginx优化配置，/etc/nginx/nginx.conf

user www-data;
worker_processes  8;
worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 00100000 01000000 10000000;

error_log  /var/log/nginx/error.log;
pid        /var/run/nginx.pid;

events {
    use epoll;
    worker_connections  51200;
    multi_accept on;
}

http {
    include       /etc/nginx/mime.types;

    access_log  /var/log/nginx/access.log;

    sendfile       on;
    keepalive_timeout  65;
    tcp_nodelay    on;
    tcp_nopush     on;

    server_names_hash_bucket_size 128;
    client_header_buffer_size 2k;
    large_client_header_buffers 4 4k;
    client_max_body_size 20m;

    ## gzip
    gzip  on;
    gzip_disable "MSIE [1-6]\.(?!.*SV1)";
    gzip_min_length 1k;
    gzip_buffers     4 16k;
    gzip_http_version 1.0;
    gzip_comp_level 2;
    gzip_types  text/plain text/css image/jpeg application/json application/x-javascript text/xml application/x-shockwave-flash application/xml application/xml+rss text/javascript;
    gzip_vary on;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}

上面的是按照服务器8个cpu来配置的，也就是每个cpu开一个worker总共8个，并且指定每个worker的序号

php-fpm优化配置，主要是进出数的配置，找到以下几个关键配置选项，在/etc/php5/fpm/poll.d/www.conf

pm = dynamic                        #这里可以设置为dynamic/static,前者为动态管理php-fpm进程，后者为静态

pm.max_children  200                #最大的子进程数量，这个参数只在pm=static模式下有效，dynamic模式得下面参控制
pm.start_servers = 200              #启动的时候开启的进程数
pm.min_spare_servers = 100          #空闲时候最少保留的进程数
pm.max_spare_servers = 300          #最大进程数

上面假如选择pm的方式为static，那么只有pm.max_children参数设置起作用，因为使用静态的模式管理进程，php-fpm管理器只会静态的设置最大的进程数量为max_children，而反过来，使用pm=dynamic，则pm.max_children不起作用了，会根据下面的三个参数联合控制。这里，pm.start_servers是要根据pm.min_spare_servers和pm.max_spare_servers两个参数的设置计算来的，公式为：pm.start_servers = pm.min_spare_servers + (pm.max_spare_servers – pm.min_spare_servers)/2。
另外，到底开启多少进程数合适呢？以及选择怎样的模式更好呢？
假如服务器配置不错，那就是用static模式，毕竟动态的管理php-fpm进程会有消耗服务器资源，以及数量上的话，一般一个php-fpm据说是消耗20-30MB的内存（我自己也没考究过-_-!）。按照这样算，1G内存的机器，大概开30个差不多了，8G的话，我多的时候是配置到了300个最大进程数量。

工厂方法定义

工厂方法模式又称为工厂模式，也叫虚拟构造器（Virtual Construct）模式或者多态工厂模式（Polymorphic Factory），在工厂模式中，父类负责定义创建对象的接口，而真正实现创建对象的任务交给子类去实现。这样作的目的是将创建对象的工作延迟到子类中去完成，由子类决定生成哪个具体的对象。

相对模于简单工厂模式来说，工厂方法模式解决了简单工厂模式的缺点-违反开放-封闭原则，将添加更多的产品种类以扩展方式就能实现，而不必去修改工厂类或者产品类。

<?php

// Factory Method

interface IAnimal {
    function Eat();
}

class Dog implements IAnimal {

    public function Feed() {
        echo "Dog Eat!\n";
        echo "<br/>";
    }
}

class Cat implements IAnimal {

    public function Eat() {
        echo "Cat Eat!";
        echo "<br/>";
    }
}

interface Feeder {
    function Feed();
}

class DogFeeder implements Feeder {

    public function Feed() {
        return new Dog();
    }
}

class CatFeeder implements Feeder {

    public function Feed() {
        return new Cat();
    }
}

// Test
$DogFeeder = new DogFeeder();
$Dog = $DogFeeder->Feed();
$Dog->Eat();

$CatFeeder = new CatFeeder();
$Cat = $CatFeeder->Feed();
$Cat->Eat();

?&gt;

上面代码中，我们将喂养动物的任务交给对应喂养动物的子类DogFeeder/CatFeeder去执行，不是在Feeder类中去写逻辑判断该喂养哪一动物。

优点

我们要另外加一新的品种动物的喂养，只需要新增一个动物类以及动物喂养类，然后在主逻辑代码里直接使用对应的动物喂养类调用喂养该动物就好，而不必去修改现在的代码，在遵循开放-封闭原则基础上做到很好的对现有系统的扩展。

缺点

我觉得没什么缺点，唯一缺点就是新增喂养动物需要新写动物类以及具体的动物喂养类，但是这个是必须的呀。

应用场景

• 类不知道自己要创建哪个对象
• 类由它的子类类确定创建哪个对象
• 类将创建对象的职责交个它的子类去实现

简单工厂模式定义

通常负责创建实例工厂类接收一个条件(参数)，来决定实例化哪一个产品类。简单工厂模式又被称为静态工厂模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

<?php

// Simple Factory

interface IAnimal {
    function Eat();
}

class Dog implements IAnimal {
    public function Eat() {
        echo "Dog Eat!";
        echo "<br/>";
    }
}

class Cat implements IAnimal {
    public function Eat() {
        echo "Cat Eat!";
        echo "<br/>";
    }
}

class SimpleFactory {
    function CreateAnimal($animal_type) {
        switch ($animal_type) {
            case 'Dog':
                return new Dog();break;
            case 'Cat':
                return new Cat();break;
            default:
                exit('Please provide the type of animal you wana to create!');
        }
    }
}

// Test
$simplefactory = new SimpleFactory();
$dog = $simplefactory->CreateAnimal('Dog');
$dog->Eat();

$cat = $simplefactory->CreateAnimal('Cat');
$cat->Eat();
?>

优点

SimpleFactory根据接收不同的参数实例化不同的动物，对动物的实例化统一交给SimpleFactory工厂类来实现，客户端不必知道动物类的具体名称或者怎么去完成实例化，而只需使用SimpleFactory类以及对应的实例化某动物的参数(“Dog”或者”Cat”等)来实例某动物就可以了。

缺点

整个模式的关键是SimpleFactory类，其中SimpleFactory创建动物方法中包含了创建动物的关键逻辑，而这往往容易违反高内聚的责任分配原则，也违反开放-封闭原则，因为要添加新的动物时候，必须修改SimpleFactory的CreateAnimal方法，而开发-封闭原则是对扩展是开放的（Open for extension），而对修改是封闭的（Close for modification）。

字

首先，我们了解这么一个知识点，计算机在处理或者运算的时候，是把数据分成一个个固定长度数据串来处理的，这些一个个的细小数据串就是计算机的字。通常，一个字包含若干个字节（每个字节通常是8位，即8个二进制数）。而且，在存储器中，每个单元存储一个字，每个字又是可以通过寻址的，字的长度是用用位来表示的，即一个字能容纳多少位二进制数，即下面的字长。

字长

计算机中每个字的位数（二进制数的个数）就叫字长。根据计算机不同，字长分为固定字长、可变字长。固定字长，即字长度不论什么情况都是固定不变的；可变字长，则在一定范围内，其长度是可变的。

计算机的字长代表计算机的处理能力，是指它一次可处理的二进制数字的数目，即一次可处理计算的数据大小。计算机处理数据的速率，自然和它一次能加工的位数以及进行运算的快慢有关。如果一台计算机的字长是另一台计算机的两倍，即使两台计算机的速度相同，在相同的时间内，前者能做的工作是后者的两倍。我们常说的32位、64位机器就是说这些机器的字长度。字长大的机器CPU，假如相同处理速度的条件下，CPU的处理数据量与字长度成正比。因此，64位机器是要比32位更强！

字节

在上面说到的字，每个字中包含若干个字节（通常一个字节占8位，8个二进制数），或者说字节是指一小组相邻的二进制数码，通常是8位（二进制数）作为一个字节。字节是构成信息的一个小单位，并作为一个整体来参加操作，比”字“小，是构成字的单位。

一个重要的信息：在计算机中，通常用多少字节来表示存储器的存储容量。例如，在C++的数据类型表示中，通常 char为1个字节，int为4个字节，double为8个字节。

有了上面的概念，我们来算算数据的存储。

1字节(byte) = 8 位(bit)   得到：

1kib = 2的10次方 bit = 1024 bit

即: 1kib=1024bit  或  1k字节(KiB,kilibyte) = 1024(字节)

同理，

1MiB=1024KiB

1M字节（MiB,Mebibyte）=1024K字节（2的20次方字节）

1GiB=1024MiB

1G字节（GiB,Gibibyte）=1024M字节（2的30次方字节）

1TiB=1024GiB

1T字节（TiB,Tebibyte）=1024G字节（2的40次方字节）

1PiB=1024TiB

1P字节（PiB,Pebibyte）=1024T字节（2的50次方字节）

1EiB=1024PiB

1 E字节（EiB,Exbibyte）=1024P字节（2的60次方字节）

…

因为硬盘生产商是以GB（十进制，即10的3次方=1000，如1MB=1000KB）计算的，而电脑（操作系统）是以GiB(2进制，即2的 10次方，如

1MiB=1024KiB）计算的，国内用户一般不分MB与Mib以及Kb与kib，直接把1MB=1000 KB为1Mib=1024kib，所以好多160GB的硬盘实际容量按计算机

实际的1MiB=1024KiB算都不到160GiB，这也可以解释为什么新买的硬盘“缺斤短两”并没有它所标示的那么大。

最后，我们来看一道传说腾讯的面试题目：

问题
在一个文件中有 10G 个整数，乱序排列，要求找出中位数，内存限制为 2G,多少次计算能找出中位数？
解答

假设整数为long，即长整形的，占8个字节，也就是8*8bit=64bit，因此这个long整数的取值范围是多少呢？就是无符号0~2^64-1次方或者有符号-2^63 ~ 2^63-1次方，好大好恐怖的数。

这个意思也就是说，假如无符号64bit的数，从0~2^64次方一个个存储在一起的话，会有多大呢？答案是：2^64 * 8kib>>1E数据量>>N个TB数据>>2G内存，也就是想说，2G的内存不可能放下从0~2^64次方的所有64bit数，当然，10G的文件也不可能存储完。

那么现在我把我们的问题重新描述下：数字区间是0~2^64次方中间的数，大概是10G数据是整个区间所有数据大小的几万分之一，然后需要你只用2G的内存，也就是说那个几万分之一再除以一个5，来计算出这10G数据中的中位数。

我们是不是可以继续这样描述问题？变成一个猜字游戏？

数字范围是1-1000的数，总共100个，你每次最多可以从1-1000中挑选20个数字来计算出这100个数字的中位数（而且每次可以读取20个数字），怎么来做从而得到这100个数字的中位数呢？我们把1-1000范围的均匀分成20个区间，0-50，50-100，100-150，150-200，…，然后每次读取20个数，遍历一次100个数后。比如一边执行计算逻辑是这样的，20个区间，哪个区间范围出现了数字的话，就记录下来，没出现的自然不记录，比如我们遍历一次的结果是这样几种情况。

1. 最糟糕的，每个区间都有出现，那么我们可以确定中位数出现在450-500这个区间，那么我们第二次就是把450-500继续划分成20个区间，然后继续遍历，这一次，请注意，每个区间数字范围是多少呢？只有50/20，不到3个数字啦。这样，我们就可以继续这样操作，就能精确到1！！！！
2. 其他情况都要比最糟糕情况好处理啦，哈哈哈

所以，问题重新回归到10G数据用2G内存处理：

64bit整数取值区间数据总数据量大小有2^64 * 8k(64bit)大小数据，也就是

1. 2G内存能存储，也就是2G字节=2*2^30K = 2^31K
2. 对64bit整数区间做2^31均匀划分，也就是2^64 除以 2^31等于2^33次方，再遍历10G数据
3. 不论怎样处理情况，一次遍历总能确定是哪一个均匀区间，而且这个区间的长度为2^33次方大小，并且咱们只有2^31次方的处理能力。
4. 因此，我们还得继续均匀划分，并处理下，这是第二次处理。第二次处理，我们剩余的区间长度就只有2^33 除以2^31等于2^2=4啦，也就能毫不费力的在第三次处理得出结果啦。

前面文章讲到rsync服务器可以配置多个同步备份项目，对于备份网站程序文件以及图片等静态文件来说我们可以直接配置rsync模块目录为网站根目录即可，比如备份整个WEB服务器根目录/var/www，可以这样配置成rsync的一个模块。

[larro]
path = /var/www
list=yes
ignore errors
auth users = root
secrets file = /etc/rsyncd.secrets
comment = This is the System file of Larro's Blog
exclude = unrsync/

对，这样就可以了。假定我们这台机器IP是192.168.1.1，然后我们在提供备份的机器上（192.168.1.2，同样安装了rsync服务）上只需要输入以下命令：

rsync -avzP --password-file=/etc/rsync/rsync.passwd root@192.168.1.1::larro /data/backup/webhost

关于具体参数详细说明可以参考使用rsync备份网站数据(1)，或者官方文档http://www.samba.org/ftp/rsync/rsync.html
这样，就讲192.168.1.1机器上/var/www里所有文件备份到/data/backup/webhost里面去了，但是这样肯定不够，因为每次得手动去输入命令同步备份，于是我们借助Linux系统的crontab命令服务，让系统自己定时去备份，(crontab详细介绍).
接着编辑crontab，把上面备份命令直接写入crontab里面：

crotab -e

在里面输入以下命令代码：

30 4 * * * /usr/bin/rsync -avzP --password-file=/etc/rsync/rsync.passwd root@192.168.1.1::larro /data/backup/webhost

上面命令表示，每天的4:30执行rsync命令，自动同步备份网站数据。

但是数据库MYSQL文件我们不好直接设置成MYSQL的数据库读写文件，例如/var/lib/mysql，数据库一直运行着，一直在读写着这些文件，如果我们直接使用rsync很容易出错，解决办法很多种，脚本里可以先停掉mysql服务，或者直接使用Mysqldump命令导出数据库文件然后打包到某个文件夹，我们把这个文件夹配置成一个rsync项目位置，然后再同步备份。
个人觉得使用mysqldump方式好点，也简单并且不必停掉mysql服务。
首先，写一个简单的shell脚本，处理导出数据库文件，并且顺便打包下放到某个位置：

#! /bin/sh
backdate = $(date +'%Y%m%d-%H')
mysqldump -uUSERNAME -pPASSWORD dbname > /data/backup/mysql-dump/dbname_"$backdate".sql
cd /data/backup/mysql-dump
tar -czf dbname_"$backup_date".tar.gz dbname_"$backup_date".sql
rm dbname_"$backup_date".sql

上面脚本大概意思就是，设置一个变量backdate值为当前时间数值，然后mysqldump导出数据库，打包压缩，删除原来的sql文件，OK
接下来就是不知任务crontab让系统定时去备份数据库了，以便rsync能随时备份到最新的数据，然后就是同上，在192.168.1.2上添加一个任务同步备份了

crontab -e
30 5 * * * /usr/bin/rsync --password-file=/etc/rsync/rsync.passwd root@192.168.1.1::mysql-backup /data/backup/mysql-dump

至此，就都做好了
//-_- Larro

单例模式，也叫单子模式，使用这个模式时候，单例对象的类只能生成一个实例。恰是只能唯一生成一个类的实例对象在有的场合里面特别合适好用。比如：

1. 系统的数据库连接对象的创建（创建多个对象既耗资源又不方便管理）
2. 某个系统全局配置对象（同理）
3. 系统统计模块对象（同理）
4. 更多…

那么，一个单例类需要满足什么样的条件呢？

1. 类的构造方法必须为私有的，即Private。（这样外部就不能通过new来创建多个实例了，我们而是通过使用一个公共的方法get_instance()得到该类的实例对象）
2. 拥有一个保存该类实例对象的私有的静态属性$instance。（在上一步，私有构造函数执行后，把刚实例化的对象存储在这里，供get_instance()获得实例对象）
3. 拥有一个对外获取该类实例对象的公共方法get_instance()。（对外获得单例类实例对象的公共接口）

那么按照上面这三个条件写出来的一个单例模式类如下(懒汉模式)：

class singleton {

private static $instance = null;

private function __construct() {}

public static function get_instance() {

if (!self::$instance instanceof self) {
self::$instance = new self();
}

return self::$instance;
}
}
?>

单例模式的实现又有两种，懒汉模式和饿汉模式，上面的DEMO代码示例就是懒汉模式的实现。
懒汉模式，即实例的初始化交给第一次使用的时候构建
饿汉模式，即实例的初始化在类的装载的时候就构建
下面也给出恶汉模式的实现:

class singleton {

private static $instance = new self();

private function __construct() {}

public static function get_instance() {
return self::$instance;
}
}
?>

注意：在多线程下使用单例模式的时候必须得特别小心，如果当唯一实例尚未创建时，有两个或多个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个或多个实例被构造出来，从而违反了单例模式中实例唯一的原则。理论上解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁，即我们可以把互斥锁加在singleton::$instance变量上，还好，PHP是单线程的，不知道模拟出来的多线程会造成单例模式的线程不安全么？以及其他语言天生就具备这样条件，比如JAVA的synchronized关键字.

于是，在这件事情的基础上，就决定配置一个实时性比较强的数据备份，自然用rsync。至于rsync是什么东东，同学们自己Google或者百度去。

Ubuntu Server，Centos,Debian等安装rsync服务可以直接使用在线安装包。

sudo apt-get install rsync

或

yum install rsync

安装好了之后，我们接下来需要配置三个文件，分别是rsyncd.conf、rsyncd.motd、rsyncd.secrets,这三个文件分别是主配置文件、显示欢迎界面文件以及密码验证文件，并且rsyncd.conf默认是不存在的，得自己创建。

touch rsyncd.conf

接下来，在该配置文件里写入如下配置代码:

# Distributed under the terms of the GNU General Public License v2
# 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.1

#uid = nobody
#gid = nobody
uid = root
gid = root
use chroot = yes
read only = yes

#limit access to private LANs
hosts allow=192.168.1.2/255.255.255.0
hosts deny=*
max connections = 5
motd file = /etc/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

[larro]
path = /var/www/larro
list=yes
ignore errors
auth users = root
secrets file = /etc/rsyncd.secrets
comment = This is the System file of Larro's Blog
exclude = easylife/ samba/

大概解释下上面的配置代码：
address =192.168.1.1 rsync服务器的IP地址
uid = root 使用root用户
gid = root 使用root用户组

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

hosts allow=122.224.164.218/255.255.255.0
hosts deny=*
上面两行是指定那些客户端IP可以连接到该rsync服务器，这个配置能很大程度上提高安全性，host allow 是允许的IP列，格式为IP/网段，多个空格隔开

log file=/etc/log/rsync.log rsync的日志记录文件
以及，上面的rsyncd.conf配置文件是分为两部分，包括第一部分公共配置参数（上面解释部分）以及单个模块的配置，如上：

[larro]
path = /var/www/larro
list=yes
ignore errors
auth users = root
secrets file = /etc/rsyncd.secrets
comment = This is the System file of Larro's Blog
exclude = unrsync/

这里，是指配置了一个名为larro的同步备份项目模块：
path = /var/www/larro 是要备份的文件的位置

list = yes 参数是表示是否允许列出文件结构，一般不要配置成yes,因为这样别人就能知道文件结构了，多少是个不太安全的因素。
auth users = root 验证时候使用的用户
secrets file = /etc/rsyncd.secrets 验证时候使用的密码验证文件，就是上面提到的三个配置文件之一
comment = This is the system file of Larro’s Blog 这个是当你列出该项目模块时候的一个说明文字，可以任意配置
exclude = unrsync/ 配置项目模块里你不想同步备份的文件及文件夹，多个空格隔开
至此，rsyncd.conf配置文件弄好了,具体的其他详细配置项目在官方配置文档里查看，大家可仔细参考，接下来来配置rsyncd.motd,rsyncd.secrets.

rsyncd.motd也是可以任意配置，因为它仅仅是一个显示欢迎的话语，不过可以写得工整点，比如：

+++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Welcome to use the rsync +
+++++++++++++++++++++++++++++++++++++++++++++++++++++

然后配置rsyncd.secrets,前面rsyncd.conf里面使用的验证用户名是root,那么这里面配置的就是root的验证密码.

echo "mypasswod" > /etc/rsyncd.secrets
chown root /etc/rsyncd.secrets
chmod 600 /etc/rsyncd.secrets

听上去有点恐怖，太不安全了吧呵呵，这个配置文件权限必须是设置成600，不然无法使用rsync服务，到时候会提示以下错误信息：

password file must not be other-accessible
continuing without password file
Password:

这样子就没关系了，因为权限设置为600，也就是只有root用户本身才能读写，也就是说其他用户登录系统后，并不能查看到root的账户信息，不过前提是你是这样设置的并且rsync服务被你配置成功了，呵呵。
到这里，一个rsync服务器上面的简单配置就好了。
启动服务：

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

上面命令是通过–daemon参数在后台启动rsync服务，并且通过使用/etc/rsyncd.conf配置文件来启动rsync服务，如果配置文件为默认的/etc/rsyncd.conf则可以不使用–config参数来指定配置文件位置。

然后你得弄另外一个机器192.168.1.2来备份上面机器项目文件。
一样，先安装rsync。
然后，使用下面命令测试下：

rsyncd --list-only root@192.168.1.1::larro

之后会提示输入密码,成功后会列出larro模块下所有的文件，或者通过在客户机上配置存放一个密码文件来访问，省得每次都提示输入密码，创建某个rsync账户的密码文件，比如上面用的root密码。

mkdir /etc/rsync
touch /etc/rsync/rsync.larro.passwd
echo "mypassword" > /etc/rsyc/rsync.larro.passwd

然后你就可以直接这样使用命令：

rsync --list-only --passwd-file=/etc/rsync/rsync.larro.passwd root@19\
2.168.1.1::larro

rsync有六种不同的工作模式：

1. rsync [OPTION]… SRC [SRC]… [USER@]HOST:DEST
2. rsync [OPTION]… [USER@]HOST:SRC DEST
3. rsync [OPTION]… SRC [SRC]… DEST
4. rsync [OPTION]… [USER@]HOST::SRC [DEST]
5. rsync [OPTION]… SRC [SRC]… [USER@]HOST::DEST
6. rsync [OPTION]… rsync://[USER@]HOST[:PORT]/SRC [DEST]

解释：

1. 拷贝本地文件；当SRC和DES路径信息都不包含有单个冒号”:”分隔符时就启动这种工作模式。
2. 使用一个远程shell程序（如rsh、ssh）来实现将本地机器的内容拷贝到远程机器。当DST路径地址包含单个冒号”:”分隔符时启动该模式。
3. 使用一个远程shell程序（如rsh、ssh）来实现将远程机器的内容拷贝到本地机器。当SRC地址路径包含单个冒号”:”分隔符时启动该模式。
4. 从远程rsync服务器中拷贝文件到本地机。当SRC路径信息包含”::”分隔符时启动该模式。
5. 从本地机器拷贝文件到远程rsync服务器中。当DST路径信息包含”::”分隔符时启动该模式。
6. 列远程机的文件列表。这类似于rsync传输，不过只要在命令中省略掉本地机信息即可。

rsync中的参数

-a  以archive模式操作、复制目录、符号连接 相当于-rlptgoD

-r  是递归

-l  是链接文件，意思是拷贝链接文件；-p 表示保持文件原有权限；-t 保持文件原有时间；-g 保持文件原有用户组；-o 保持文件原有属主；-D 相当于块设备文件；

-z  传输时压缩；

-P  传输进度；

-v  传输时的进度等信息，和-P有点关系，自己试试。可以看文档；

-e  ssh的参数建立起加密的连接。

-u  只进行更新，防止本地新文件被重写，注意两者机器的时钟的同时

--progress  是指显示出详细的进度情况

--delete  是指如果服务器端删除了这一文件，那么客户端也相应把文件删除，保持真正的一致

--password-file=/password/path/file  来指定密码文件，这样就可以在脚本中使用而无需交互式地输入验证密码了，这里需要注意的是这份密码文件权限属性要设得只有属主可读。

在这篇文章里就先讲讲rsync的基本配置，在下一篇写写怎么通过rsync、crontab、shell来完成备份同步服务器上数据文件。

// -_-  Larro

top

将会看到如下结果界面：

会列出了进程PID,USER(所属用户),PR,%CPU,%MEM,COMMAND(命令或者服务)等参数的列表，这个显示列表是动态跟踪服务器的。
问题来了，在上面的监控中，主要查看$CPU,%MEM，COMMAND这几个参数值，上面可以看到排在前面的两个进程都肚子占用了一枚CPU的%100。另外也可以根据这个列表看出WEB服务器有多少个CPU，数数php5-cgi的行数就是了。

看到两个php-cgi进程貌似是因为程序存在问题死循环什么的了把当时处理这个脚本的CPU给占满了，在这里，虽然我们大概知道是程序某个地方存在严重的问题，但是我们不能具体定位出来到底是系统的哪段文件出问题了。

于是，/proc来帮我们了，我们找到哪个进程在耗CPU，

对，PID为24207和24219这两家伙，咱们来用/proc虚拟文件系统来定位吧。

ls -l /proc/24219 # 后面的数字为上面的PID

注意上图中蓝色的路径，对，这个路径就是此段程序执行的代码路径，定位到了吧，然后你就可以在这个路径下去找那原因了

sudo apt-get install bmon

然后就可以查看某一块网卡的带宽流量情况了，比如查看eth0的：

bmon -p eth0

可以看到如下显示：

Bmon查看网络带宽流量情况

其中，RX表示流入，TX流出，RX rate是流入比率，TX Rate流出比率。更多bmon用法可以man bmon查看。

另外，更加喜人的是它能提供与Apache/Nginx等WEB服务器配合以Html方式动态显示流量监控结果，输入以下命令：

bmon -I distribution:multicast -o null -O html:path=/var/www/dirname/

这里注意下，上面的目录”/var/www/dirname/”最好不要用网站的根目录，因为执行下这个命令的话，它会生成一个index.html文件，而我们网站一般由一个index默认文档，一般index解析为:index.html index.htm index.php这三个文件。

所以，当它生成的index.html替换网站根目录的index.html文件的时候，访问网站时候默认就访问到bmon的统计页面了。

我们可以把他放在其他位置，然后加一个Http Auth来设定一定的权限来查看。

比如我们的网站根目录是：/var/www/website

我们把它生成的统计文件放在/var/www/website/bmon下，通过配置Nginx的Http auth_basic来控制访问权限。

在网站配置文件里加下面这么一段

location ~ ^/bmon/ {
    auth_basic Hello_Auth;
    auth_basic_user_file /data/auth/manage_auth;</pre>
}

上面的auth_basic Hello_auth;只是给这个验证加一个类似提示语的，可以任何；auth_basic_user_file 是用来存储http登录账户密码的，得用htpasswd工具来生成。具体如下：

htpasswd -c /data/passwd username

提示输入密码，就会创建一个username用户，并在/data/目录下生成username的passwd文件。

最终，通过浏览器访问http://www.xxx.com/bmon/就能看到监控的网页形式数据了。

SVN可以有好几种连接方式，我这里使用的是自带的SVN://协议访问。还有通过配置apache2来使用http://访问。或者文件协议file://.

首先安装Subversion,服务器环境为Ubuntu Server.

sudo apt-get install subversion

安装成功后，就创建版本库了。

先创建一个存放版本库的文件夹，方便管理。

mkdir /var/svn

根据项目需要，创建几个不同的版本库。

cd /var/svn
svnadmin create /var/svn/aaa

执行以上命令后，可以查看aaa这个文件夹里有些什么东西：

cd aaa
ls

会看到列出：conf  db  format  hooks  locks  README.txt

进入配置文件夹conf,输命令：

cd conf
ls

可以看到列出：authz  passwd  svnserve.conf几个文件，这里说明下：

svnserve.conf:这个版本库的配置文件，包括如何验证SVN访问，访问配置文件等。命令打开编辑它：

vi svnserve.conf

看到以下代码：

[general]
# anon-access = read
# auth-access = write
...
# password-db = passwd  # 密码验证文件位置，这里去掉注释即可，为同目录下passwd文件
...
# authz-db = authz      # 同上，用户验证文件，保存可以访问用户验证信息，等下会配置
...
# realm = My first repostory

# 注释都去掉

realm = 一个类似Title说明，可以填任何字符，一般 reaml = ProjectName.

保存退出
然后编辑passwd

vi  passwd

这里配置用户信息，在[users]下输入：

[users]
username = password   # 形式如这样，用户名 = 密码，多个用户名多写几行就是

保存退出，编辑authz文件，

vi authz

下面是我添加的代码：

[groups]        # 群组
# harry_and_sally = harry,sally
# harry_sally_and_joe = harry,sally,
aaa = root,hewei       # 用户组 = 用户名,用户名,用户名(用户名为刚才passwd里添加的用户，多个用","隔开)

[aaa:/]     # 版本库 文件夹权限配置。这里表示aaa版本库根目录下
@aaa = rw   # 对用户组赋予权限，格式:@用户组 = rw (r,读 w,写 或者为空)

到此一个版本库配置完成。

可以启动svnserv来运作。

svnserve -d -r /var/svn/       # -d表示后台运行方式启动， -r /var/svn 对svn这个目录启动

则现在可以通过以下方式连接上SVN服务器了。

比如我使用TSVN客户端，地址：svn://111.111.111.111/aaa

验证输入配置时候的用户名密码就OK了。

配置多个版本库只要再建立一个版本库：

svnadmin create -r /var/svn/bbb

然后配置同上。完了重新启动下svnserve:

killall svnserve
svnserve -d -r /var/svn/

当然，大部分时候我们可能需要配置SVN提交时候同步到WEB服务器文件目录上去，下次再把相关配置分享出来吧。

// -_-  Larro