Strong It

使用fio测试磁盘I/O性能

2016-07-22T16:00:00.000Z

前言

fio是测试IOPS的非常好的工具，用来对硬件进行压力测试和验证，支持13种不同的I/O引擎，包括:sync,mmap, libaio, posixaio, SG v3, splice, null, network, syslet, guasi, solarisaio 等等。

简单好用的磁盘性能测试工具

测试准备

工具：fio- Flexible IO Tester
官网：
[http://freecode.com/projects/fio] (http://freecode.com/projects/fio)
[http://brick.kernel.dk/snaps/] (http://brick.kernel.dk/snaps/)
扩展阅读：
fio man：[http://linux.die.net/man/1/fio] (http://linux.die.net/man/1/fio)

注意：性能测试建议直接通过写裸盘的方式进行测试，会得到较为真实的数据。但直接测试裸盘会破坏文件系统结构，导致数据丢失，请在测试前确认磁盘中数据已备份。

安装：

#yum安装
yum install libaio-devel fio
#手动安装
yum install libaio-devel
wget http://brick.kernel.dk/snaps/fio-2.2.10.tar.gz
tar -zxvf fio-2.2.10.tar.gz
cd fio-2.2.10
make $ make install

fio用法

fio分顺序读，随机读，顺序写，随机写，混合随机读写模式。

filename=/dev/sdb1   #测试文件名称，通常选择需要测试的盘的data目录
direct=1             #测试过程绕过机器自带的buffer。使测试结果更真实
rw=randwrite         #测试随机写的I/O
rw=randrw            #测试随机写和读的I/O
bs=16k               #单次io的块文件大小为16k
bsrange=512-2048     #同上，提定数据块的大小范围
size=5G              #本次的测试文件大小为5g，以每次4k的io进行测试
numjobs=30           #本次的测试线程为30个
runtime=1000         #测试时间1000秒，如果不写则一直将5g文件分4k每次写完为止
ioengine=psync       #io引擎使用psync方式
rwmixwrite=30        #在混合读写的模式下，写占30%
group_reporting      #关于显示结果的，汇总每个进程的信息

lockmem=1G           #只使用1g内存进行测试
zero_buffers         #用0初始化系统buffer
nrfiles=8            #每个进程生成文件的数量

实例：

#顺序读
fio -filename=/dev/sda -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=16k -size=200G -numjobs=30 -runtime=1000 -group_reporting -name=mytest

#顺序写
fio -filename=/dev/sda -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=16k -size=200G -numjobs=30 -runtime=1000 -group_reporting -name=mytest

#随机读
fio -filename=/dev/sda -direct=1 -iodepth 1 -thread -rw=randread -ioengine=psync -bs=16k -size=200G -numjobs=30 -runtime=1000 -group_reporting -name=mytest

#随机写
fio -filename=/dev/sda -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=16k -size=200G -numjobs=30 -runtime=1000 -group_reporting -name=mytest

#混合随机读写
fio -filename=/dev/sda -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=16k -size=200G -numjobs=30 -runtime=100 -group_reporting -name=mytest -ioscheduler=noop

也可以添加到配置文件里测试：

#复制下面的配置内容，将directory=/path/to/test修改为你测试硬盘挂载目录的地址，并另存为fio.conf

[global]
ioengine=libaio
direct=1
thread=1
norandommap=1
randrepeat=0
runtime=60
ramp_time=6
size=1g
directory=/path/to/test

[read4k-rand]
stonewall
group_reporting
bs=4k
rw=randread
numjobs=8
iodepth=32

[read64k-seq]
stonewall
group_reporting
bs=64k
rw=read
numjobs=4
iodepth=8

[write4k-rand]
stonewall
group_reporting
bs=4k
rw=randwrite
numjobs=2
iodepth=4

[write64k-seq]
stonewall
group_reporting
bs=64k
rw=write
numjobs=2
iodepth=4

#测试
fio fio.conf

测试结果主要关注bw和iops结果
bw：磁盘的吞吐量，这个是顺序读写考察的重点
iops：磁盘的每秒读写次数，这个是随机读写考察的重点

硬盘性能指标

顺序读写 （吞吐量，常用单位为MB/s）：文件在硬盘上存储位置是连续的。
适用场景：大文件拷贝（比如视频音乐）。速度即使很高，对数据库性能也没有参考价值。
4K随机读写 （IOPS，常用单位为次）：在硬盘上随机位置读写数据，每次4KB。
适用场景：操作系统运行、软件运行、数据库。

爬虫利器之BeautifulSoup4

2016-07-14T16:00:00.000Z

Beautiful Soup是python的一个库，最主要的功能是从网页抓取数据。官方解释如下：

1
2
3

Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。
Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，Beautiful Soup就不能自动识别编码方式了。然后，你仅仅需要说明一下原始编码方式就可以了。
Beautiful Soup已成为和lxml、html6lib一样出色的python解释器，为用户灵活地提供不同的解析策略或强劲的速度。

语法：

| Python标准库 | BeautifulSoup(markup, “html.parser”)| Python的内置标准库；执行速度适中；文档容错能力强 | Python 2.7.3 or 3.2.2)前的版本中文档容错能力差

| lxml HTML 解析器 | BeautifulSoup(markup, “lxml”) | 速度快；文档容错能力强 | 需要安装C语言库

| lxml XML 解析器 | BeautifulSoup(markup, [“lxml”, “xml”])BeautifulSoup(markup, “xml”) | 速度快；唯一支持XML的解析器 | 需要安装C语言库

| html5lib | BeautifulSoup(markup, “html5lib”) | 最好的容错性；以浏览器的方式解析文档；生成HTML5格式的文档 | 速度慢；不依赖外部扩展 |

soup.select ( ) 选择标签问题

代码原型是这样的：

import requests
from bs4 import BeautifulSoup

web_data = requests.get('url')
soup = BeautifulSoup(web_data.text,'lxml')
data = soup.select('选择内容')
print (data)

url: http://www.meihua.info/

要截取一篇文章的以下字段：

日期（今天）

阅读量（阅读65）

类型（业界）

文章标签（微信，阅读量）

那么在浏览器中鼠标右键点击审查 -> 找到字段的具体代码 -> 右键选择Copy -> Copy selector，复制的内容如下：

1	body > div.main-frame > div.news-list-list > ul > li:nth-child(1) > div.time > span > span:nth-child(1)

如果直接那这个作为select ( )的参数是不行的，li:nth-child(1)要去掉，这是CSS的高级选择器，而且select ( )不支持这种类型，去掉就行。然后还要查看html结构的层级（span）。

以下是我修改的select ( )参数内容：

1	body > div.main-frame > div.news-list-list > ul.list.news-list > li > div.time > span.desc-font.date > span

运行代码试一下：

import requests
from bs4 import BeautifulSoup as bs

web_data = requests.get('http://www.meihua.info/?page=1')

soup = bs(web_data.text,'lxml')
post_date = soup.select('body > div.main-frame > div.news-list-list > ul.list.news-list > li > div.time > span.desc-font.date > span')[0]

print (post_date.get_text())

--输出结果--
今天

编码输出问题

在抓取这个网页 http://www.ikanchai.com/ 的时候，出现乱码，如下：

import requests
from bs4 import BeautifulSoup as bs

web_data = requests.get('http://www.ikanchai.com/')
soup = bs(web_data.text,'lxml')
dates = soup.select('div.sort.channel.clearfix > ul > li > a')

for data in dates:
    print (data)
-----输出结果-----
<a href="http://www.ikanchai.com/view/">è§‚ç‚¹</a>
<a href="http://www.ikanchai.com/start/">åˆ›æŠ•</a>
<a href="http://www.ikanchai.com/evaluation/">è¯„æµ‹</a>
<a href="http://www.ikanchai.com/vr/">VR</a>
<a href="http://www.ikanchai.com/push/">ä¸“æ </a>
<a href="http://app.ikanchai.com/roll.php">åŠ¨æ€</a>

编码问题，加一句web_data.encoding = ‘utf-8’即可以了，具体的编码选择在html文档开头有说明。

get_text和get()的使用

get_text()，是返回选择的标签文本，具体可以参考文档：http://beautifulsoup.readthedocs.io/zh_CN/latest/#get-text
get(‘’)，这是选择标签中的属性(也就是里面有=符号的左边)，比如
1
<li><a class="reference internal" href="#next-siblings-previous-siblings">

中，选择li > a这个标签之后，则可以用get(‘href’)获取其中的链接。

findall()和select()的区别

待续

Ansible Playbook应用

2016-07-02T16:00:00.000Z

Playbooks 与 adhoc 相比,是一种完全不同的运用 ansible 的方式,是非常之强大的.简单来说,playbooks 是一种简单的配置管理系统与多机器部署系统的基础.与现有的其他系统有不同之处,且非常适合于复杂应用的部署.Playbooks 可用于声明配置,更强大的地方在于,在 playbooks 中可以编排有序的执行过程,甚至于做到在多组机器间,来回有序的执行特别指定的步骤.并且可以同步或异步的发起任务.我们使用 adhoc 时,主要是使用 /usr/bin/ansible 程序执行任务.而使用 playbooks 时,更多是将之放入源码控制之中,用之推送你的配置或是用于确认你的远程系统的配置是否符合配置规范.

目录结构

以下为playbook标准的目录结构，以不同级别目录层级的文件进行拆分。

[root@localhost playbooks]# tree .
.
├── playbooks.yml
├── roles
│   ├── common
│   │   ├── files
│   │   ├── handlers
│   │   ├── meta
│   │   ├── tasks
│   │   │   └── main.yml
│   │   └── vars
│   ├── mysql
│   │   └── tasks
│   │   └── main.yml
│   ├── nginx
│   │   ├── handlers
│   │   │   └── main.yml
│   │   └── tasks
│   │   └── main.yml
│   └── php-fpm
│       └── tasks
│       └── main.yml
└── site.yml

site.yml，playbook主要配置文件，例：

---
- name: Install web
  hosts: webserver
  user: root
  roles:
    - common
    - nginx
    - mysql

../tasks/main.yml，任务文件，例：

---
- name: Install nginx
  yum: name=nginx state=present
  notify: start nginx

../handlers/main.yml，处理程序文件，例：

1
2
3

---
- name: start nginx
  service: name=nginx state=started

../vars/main.yml，变量文件，例：

1 2	--- ntpserver: time.windows.com

../templates/，用于template调用，例：

1
2
3

---
- name: copy configure
  template: src=nginx.conf  dest=/etc/nginx/nginx.conf

../files/，其内的文件无需路径，直接引用，例：

1
2
3

---
- name: include files
  - include: nginx.yml

条件与循环

如果系统为redhat则重启

tasks:
  - name: reboot redhat host
    command: /usr/sbin/reboot
    when: ansible_os_family == "RedHat"

如果result为成功状态则重启

tasks:
  - command: /bin/false
    register: result
    ignore_errors: True

  - command: /usr/sbin/reboot
    when: result|success

循环语句基础

tasks:
  - name: install LNMP
    yum: name={{ item }} state=present
    with_items:
       - nginx
       - mysql-server
       - php-fpm

循环还支持列表，使用with_flattened语句。变量文件

1
2
3

---
packages_LNMP:
  - [ 'nginx', 'mysql-server', 'php-fpm' ]

引用

- name: Install LNMP
  yum: name={{ item }} state=present
  with_flattened:
     - packages_LNMP

简单示例

nginx安装的playbook示例

---
- hosts: webserver #指定主机或组
tasks:
 - name: Install nginx epel
   command: /usr/bin/rpm -Uvh http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm
 - name: Install nginx
   yum: name=nginx state=present
   notify:
   - start nginx

 - name: configure nginx
   template: src=letong.conf dest=/etc/nginx/conf.d/ 

 - name: configure www dir
   command: cp -r letong-web/ /www/ 

 handlers:
   - name: start nginx
     service: name=nginx state=started

执行测试

[root@localhost playbooks]# ansible-playbook playbooks.yml 

PLAY [webserver] ************************************************************** 
GATHERING FACTS *************************************************************** 
ok: [192.168.1.68]

TASK: [Install nginx] ********************************************************* 
changed: [192.168.1.68]

NOTIFIED: [start nginx] ******************************************************* 
changed: [192.168.1.68]

PLAY RECAP ******************************************************************** 
192.168.1.68               : ok=3    changed=2    unreachable=0   failed=0

访问测试

[root@localhost playbooks]# curl -I http://192.168.1.68
HTTP/1.1 200 OK
Server: nginx/1.6.2
Date: Thu, 11 Dec 2015 05:00:13 GMT
Content-Type: text/html
Content-Length: 3700
Last-Modified: Wed, 22 Oct 2015 19:50:12 GMT
Connection: keep-alive
ETag: "54480a74-e74"
Accept-Ranges: bytes

Ansible简单配置篇

2016-06-30T16:00:00.000Z

ansible自动化工具只需要在一台机器上安装，其他机器不需要安装任何东西，这就是ansible比puppet, saltstck方便的地方。ansible的特点有哪些呢？下面为你逐个介绍：
(1)、轻量级，无需在客户端安装agent，更新时，只需在操作机上进行一次更新即可；
(2)、批量任务执行可以写成脚本，而且不用分发到远程就可以执行；
(3)、使用python编写，维护更简单；
(4)、基于SSH工作；
(5)、支持文件同步并且对修改之前的文件进行备份，支持回滚；

官方原文档: https://docs.ansible.com/ansible/index.html
中文翻译版：http://www.ansible.com.cn/index.html

简单示例

vi /etc/ansible/hosts

[ts]
192.168.1.106
执行命令 ansible ts -m ping

192.168.1.106 | success >> {
    "changed": false, 
    "ping": "pong"
}

主机或组规则

目录 /etc/ansible/hosts

# Ex 1: 未分组的主机.

green.example.com
blue.example.com
192.168.100.1
192.168.100.10

＃自定义webservers组
[webservers]
alpha.example.org
beta.example.org
192.168.1.100
192.168.1.110
#使用正则表达式
www[001:006].example.com

分离主机与组的特定数据，Ansible支持将/etc/ansible/hosts定义的主机名与变量单独剥离出来放到指定存放文件中，以YAML格式保存

1 2	/etc/ansible/group_vars/ /etc/ansible/host_vars/

模块应用

远程命令模块

1
2
3

ansible dbserver -m command -a "ls /"
ansible dbserver -m script -a "ats.sh start"
ansible dbserver -m shell -a "ats.sh"

复制模块

1	ansible dbserver -m copy -a "src=/1.txt dest=/data/ owner=root group=root mode=777"

查看文件状态模块

1	ansible dbserver -m stat -a "path=/data/1.txt"

URL下载模块

1	ansible dbserver -m get_url -a "url=http://letong.me dest=/data/ mode=777 force=yes"

yum模块

1	ansible dbserver -m yum -a "name=git state=latest"

service模块

1	ansible dbserver -m service -a "name=httpd state=restarted"

user模块

1 2	ansible dbserver -m user -a "name=letong comment='Hello letong' " ansible dbserver -m user -a "name=letong state=absent remove=yes"

mount模块

1	ansible dbserver -m mount -a "name=/data src=/dev/sdb1 fstype=ext4 opts=ro state=present"

cron模块

1	ansible ts -m cron -a "name='ls dir' hour='5,2' job='ls -l'"

Node.js原子性操作MongoDB

2016-06-20T16:00:00.000Z

假设基础数据为:


{
    "name" : "cb",
    "data" : 0,
}

有时候为了充分利用多核,会同时开启多个node进程,但是若部分代码若涉及到操作mongodb就会有下面现象.
“理想情况下”,多个进程执行完后得数据为:


{
    "name" : "cb",
    "data" : 6000,
}

其实不然 !

我们看看获得结果是怎么样的.


co(function* () {
    for (var i=0; i< 3000; i++) {
        var getTest = yield mongoCtest.findOne({"name":"cb"}, {"fields":{"_id":0}});
        getTest.data =  getTest.data+1;
        console.log(getTest);
        yield mongoCtest.update({"name":"good"}, {"$set":getTest});
    }
})();

上面的程序同时开两个,多个进程同时操作一个数据.
可能结果会是:

我们知道Mongo是不支持事务的,如果你能容忍上面的弱一致性,那么没问题.但是如果你不能容忍，要么考虑MySql关系型数据库,要么自己解决事务问题.

下面我来说下基于Mongo怎么解决事务问题.
我们需要对每个数据加一个version来控制.直接上代码:


co(function* () {
    for (var i=0; i< 3000; i++) {
        while (1) {
            var getTest = yield mongoCtest.findOne({"name":"cb"}, {"fields":{"_id":0}});
            getTest.data =  getTest.data+1;
            var originalVer = getTest.ver;
            getTest.ver = getTest.ver+1;
            console.log(getTest);
            var ret = yield mongoCtest.update({"name":"cb", "ver":originalVer}, {"$set":getTest});
            if (ret)  break;
        }
    }
})();

下面就是我们想要的结果:)

MongoDB Map-Reduce 原理及提速

2016-06-17T16:00:00.000Z

想要优化Map-reduce就要深入理解其原理.

Map-Reduce基本原理请见下图:

整个数据处理流程可以参见官方上图,先对要进行处理的数据进行Query,然后针对Query的数据进行map,最后针对map的数据进行reduce.

简单了解之后,我们这里取一个例子熟悉下整个过程:

数据基本格式为:


/* 0 */
{
    "code" : "A",
    "uid" : "id_1",
    "count" : 1
}

/* 1 */
{
    "code" : "A",
    "uid" : "id_1",
    "count" : 1
}

/* 2 */
{
    "code" : "B",
    "uid" : "id_1",
    "count" : 1
}

/* 3 */
{
    "code" : "B",
    "uid" : "id_2",
    "count" : 2
}

目的:根据uid计算出count的和且这个合涉及到哪些code.

很快就可以写出Map和Reduce函数:


var map = function() {
    emit(this.uid, {"code":this.code || "", count:this.count || 1});
};

var reduce = function(key, values) {
    var result = {code:{}, count:0};
    values.forEach(function(val) {
                result.code[val.code] = 1;
                result.count += val.count;
                });
    return result;
}

结果为:


/* 0 */
{
    "_id" : "id_1",
    "value" : {
        "code" : {
            "A" : 1,
            "B" : 1
        },
        "count" : 3
    }
}

/* 1 */
{
    "_id" : "id_2",
    "value" : {
        "code" : "B",
        "count" : 2
    }
}

这次我省去了query的过程,直接进行Map和Reduce,我们来拆解下过程:

首先,MongoDB会扫描整个数据表(这里省去Query)遍历所有documents,对于每个docuemnt都会根据key(uid)进行map存储.

其次,这个时候MongoDB会对记录的size进行检查( mongod checks every 100 records that the size of the map is not over 50KB, if so it runs reduce on ALL current keys. If size of map is still over 100KB, it dumps all current documents to disk in an “incremental” collection.)

最后根据map的数据进行reduce操作.

好,上面三点是大概的过程,对于Mapping过程,上面实例中会进行


{"id_1", values:[{"code":"A", "count":1}, {"code":"A", "count":1}, {"code":"B", "count":1}}

这样的Emit操作.这点是需要注意的.然后以这样得方式传入到Reduce进行处理,所以Reduce必须对values进行forEach处理.

通过上面这个过程,还有一点要非常注意:如果有很多文档,而且这些文档的分布是非常随机的,当内存比较小时,MongoDB会采取把这些数据存在一个inc自增的文档中.

比方说:我有A, B, C三个key, 每个key有100个, 但是这些key都是随机分布的比如A…B…A…B..C…A..B..C..当我要先对A进行Emit时需要把所有是A的key的document获取出来,那么这个过程当内存很小时需要把大部分得document存储到磁盘上.然后内存和磁盘一直交换数据,至到把A全部找出为止(期间每在内存中操作的部分A会先Emit出去).

这种操作肯定很耗时, 如果我们对key进行索引且排好序,那么排好序的A就会大部分在内存中,减少了内存和磁盘的切换次数.

所以对大数据加排序是必须要有的.这个细节至少可以提高很多倍得处理速度.

基本原理先说到这,还有更多实践干货留着下次说.

MONGODB的BASIC INDEXES 和 COMPOUND INDEXES 研究

2016-06-11T17:18:41.000Z

前几天看到一个关于 MongoDB 深入索引的PPT

MongoDB Indexing: The Details

仔细的从头看到尾, 里面有个关于Compound Indexes的Range and Equality的讲解,在ppt第129页,重新回顾下这个例子.向一个collection中插入 9 条数据,像下面这样:


> db.good.find()
{ "_id" : ObjectId("4e8d629d8ad8bdf2ed6c1990"), "x" : 1, "y" : "b" }
{ "_id" : ObjectId("4e8d62a38ad8bdf2ed6c1991"), "x" : 3, "y" : "d" }
{ "_id" : ObjectId("4e8d62ad8ad8bdf2ed6c1992"), "x" : 4, "y" : "g" }
{ "_id" : ObjectId("4e8d62b28ad8bdf2ed6c1993"), "x" : 5, "y" : "c" }
{ "_id" : ObjectId("4e8d62ba8ad8bdf2ed6c1994"), "x" : 6, "y" : "a" }
{ "_id" : ObjectId("4e8d62c18ad8bdf2ed6c1995"), "x" : 7, "y" : "e" }
{ "_id" : ObjectId("4e8d62ce8ad8bdf2ed6c1996"), "x" : 8, "y" : "c" }
{ "_id" : ObjectId("4e8d62d38ad8bdf2ed6c1997"), "x" : 9, "y" : "f" }
{ "_id" : ObjectId("4e8d719a6cee6416a5a75a43"), "x" : 5, "y" : "d" }

然后给x 和 y进行联合索引


db.good.ensureIndex({x:1,y:1})

我们来进行这样的查找


> db.good.find({x:{$gte:4}, y:’c’}).explain()
{
    "cursor" : "BtreeCursor x_1_y_1",
        "nscanned" : 7,
        "nscannedObjects" : 2,
        "n" : 2,
        "millis" : 0,
        "nYields" : 0,
        "nChunkSkips" : 0,
        "isMultiKey" : false,
        "indexOnly" : false,
        "indexBounds" : {
            "x" : [
                [
                    4,
                    1.7976931348623157e+308
                ]
            ],
            "y" : [
                [
                    "c",
                    "c"
                ]
            ]
        }
}

可以看出 nscanned 非常高! 而 n只有 2 .官网上有这样一句话:

If nscanned is much higher than nreturned, the database is scanning many objects to find the target objects. Consider creating an index to improve this.

这里nscanned可以认为是扫描的记录数.n为返回的记录数

让我们配合PPT看下 nscanned:7是怎么来的:

这是MongoDB的B-tree索引树,因为x>=4 && y=’c’,所以先选择左枝搜索,左枝搜索了4/g 和 5/c ,(5/c符合条件),然后搜索右枝搜索了 7/e, 6/a ,8/c, 9/f ,(8/c符合条件). 任何符合的 x都要被check一下.

###延伸

看了PPT后到此结尾了, 真遇到这种情况,效率可不乐观,于是稍微思考了下, y 在这颗树中只有两个节点含有,也就是说既然是 ‘与’ 那就只要先把 y 筛选出来 ,搜索次数就大大减半了 .

我们在 y 上再进行Basic Indexes 的建立.


db.good.ensureIndex({y:1})

这样如果搜索时会先搜索 y ,也就只有2次搜索了.看下实际情况:


> db.good.find({x:{$gte:4}, y:’c’}).explain()
{
    "cursor" : "BtreeCursor y_1",
        "nscanned" : 2,
        "nscannedObjects" : 2,
        "n" : 2,
        "millis" : 0,
        "nYields" : 0,
        "nChunkSkips" : 0,
        "isMultiKey" : false,
        "indexOnly" : false,
        "indexBounds" : {
            "y" : [
                [
                    "c",
                    "c"
                ]
            ]
        }
}

正如预料的一样. 直接走基本索引了.

SSL基本配置

2016-06-09T16:00:00.000Z

为了可以正常使用 https 地址访问 Rancher 服务器，您需要设置代理的证书卸载功能。同时，我们提供了一些配置 NGINX 或 Apache 代理的例子，当然，您也可以使用其他工具。

需求

除了典型的 Rancher 服务器需求您还需要：

有效的 SSL 证书：如果您的证书不包含在 Ubuntu CA 中，请参照自签名证书说明。
配置 DNS 记录。

启动 Rancher 服务器

在我们的示例配置方案中，所有流量将通过代理被发送到 Rancher 服务器的 Docker 容器中。也有替代的配置方案可以实现，但这个示例相对比较简单。
启动 Rancher 服务器，这里我们添加了选项 --name=rancher-server 用来连接代理容器和 Rancher 服务器容器。

1	$ sudo docker run -d --restart=always --name=rancher-server rancher/server

注意：

在我们的示例中，我们假设代理运行在单独的容器中。如果您的代理计划由主机提供服务，需要将 Rancher 容器的 8080 端口映射至本地主机，可以向 docker run 命令添加参数 -p 127.0.0.1:8080:8080 实现。

如果您想使用现有的 Rancher 实例，您可以基于现有的 Rancher 实例创建一个新的 Rancher 实例。

若 Rancher 实例的 MySQL 数据库运行在容器内，在启动新的 Rancher 实例时，请参照升级说明创建数据容器并且在启动时添加 --volumes-from=<data_container> 。
若 Rancher 实例使用了绑定挂载数据库的方式，请参照绑定挂载实例升级说明。
若 Rancher 实例使用外部数据库，则直接停止并删除现有的 Rancher 实例容器，并参照外部数据库连接说明启动新的容器。

注意：

在新的 Rancher 实例容器运行后，请确认已经删除了旧的 Rancher 实例容器，否则，在您的主机重启后，因为我们在 docker run 命令时加入了 --restart=always 参数，会导致旧容器启动。

NGINX 配置示例

这里的配置是 NGINX 运行的最低配置，您应该定制配置来满足您的需求。

节点设置

rancher-server 是您的 Rancher 服务器容器名。您必须在启动 Rancher 服务器容器的时候加入 --name=rancher-server 选项。并且在启动 NGINX 容器的时候加入 --link=rancher-server 选项才能使这些配置正常工作。
<server> 可以任意命名，但是必须保证 http 和 https 配置中的名称相同。

upstream rancher {
    server rancher-server:8080;
}

server {
    listen 443 ssl;
    server_name <server>;
    ssl_certificate <cert_file>;
    ssl_certificate_key <key_file>;

    location / {
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Port $server_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://rancher;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        # This allows the ability for the execute shell window to remain open for up to 15 minutes. Without this parameter, the default is 1 minute and will automatically close.
        proxy_read_timeout 900s;
    }
}

server {
    listen 80;
    server_name <server>;
    return 301 https://$server_name$request_uri;
}

APACHE 配置示例

这是一个 Apache 的配置。

节点设置

<server_name> 是您 Rancher 服务器容器的名字，所以在启动 Apache 容器时需要加入 --link=<server_name> 才能使配置正常工作。
在代理配置中，您需要替换 rancher 为您的信息。

<VirtualHost *:80>
  ServerName <server_name>
  Redirect / https://<server_name>/
</VirtualHost>

<VirtualHost *:443>
  ServerName <server_name>

  SSLEngine on
  SSLCertificateFile </path/to/ssl/cert_file>
  SSLCertificateKeyFile </path/to/ssl/key_file>

  ProxyRequests Off
  ProxyPreserveHost On

  RewriteEngine On
  RewriteCond %{HTTP:Connection} Upgrade [NC]
  RewriteCond %{HTTP:Upgrade} websocket [NC]
  RewriteRule /(.*) ws://rancher:8080/$1 [P,L]

  RequestHeader set X-Forwarded-Proto "https"
  RequestHeader set X-Forwarded-Port "443"

  <Location />
    ProxyPass "http://rancher:8080/"
    ProxyPassReverse "http://rancher:8080/"
  </Location>

</VirtualHost>

更新主机注册

在 Rancher 配置完成后，用户界面将使用 https://<your domain>/ 访问。在添加主机之前，您需要正确配置 SSL 方式的主机注册地址。

在 AWS ELB 后使用 SSL 运行 Rancher

默认情况下，ELB 不支持在 HTTP/HTTPS 模式下启用 websockets 。由于 Rancher 使用了 websockets ，则 ELB 必须修改配置以便 Rancher 的 websockets 可以正常工作。

Rancher 的 ELB 配置需求

启用代理协议模式
配置 TLS/SSL 方式的前端以及 TCP 方式的后端

使用自签名证书（测试）

免责声明

这个配置可以工作在单节点 Rancher 服务器（非HA安装）模式的核心服务上，没有人验证是否支持 Rancher 目录是否被支持。

Rancher Compose 命令行默认需要将 CA 证书存储在操作系统，请参照 Golang。

服务器必备条件

CA 证书 PEM 格式的文件
已经签署证书的 Rancher 服务器
NGINX 和 Apache 配置证书卸载，并反向代理到 Rancher 服务器

Rancher 服务器

使用修改后的 Docker 命令启动 Rancher 服务器容器。证书必须在容器中被命名为 ca.crt。
1
$ sudo docker run -d --restart=always -p 8080:8080 -v /some/dir/cert.crt:/ca.crt rancher/server
注意：

如果你正在运行 NGINX 或 Apache 容器，您可以直接访问这些实例，不需要通过 Rancher 服务器的 8080 端口访问用户界面。
这条命令将会配置 Rancher 服务器的证书链，所以 Rancher 的服务，如机器配置，目录和 compose 均可以和 Rancher 服务器通讯。
如果您正在使用一个 NGINX 或 Apache 容器卸载证书，您需要在启动容器的命令增加 --link= 选项。
通过 https 访问 Rancher 用户界面，即 https://rancher.server.domain 。
更新主机注册为 SSL 方式。

注意：

除非您的机器信任了用于签署 Rancher 服务器的 CA 证书，否则当你访问页面时，浏览器会给出一个不可信网站的警告信息。

添加主机

如果您想添加主机到 Rancher ，您必须在主机上以 pem 格式将 CA 证书保存到 /var/lib/rancher/etc/ssl 目录并命名为 ca.crt 。
添加自定义主机，也就是从用户界面粘贴命令。命令已经加入了 -v /var/lib/rancher:/var/lib/rancher 选项，所以文件会被自动复制到您的主机上。

From： http://docs.rancher.com/rancher/latest/en/installing-rancher/installing-server/basic-ssl-config/

多节点高可用(HA)

2016-06-03T16:00:00.000Z

基于 Rancher v1.0.1

需求

多节点的HA配置请参照单一节点需求
- 节点需要开放的端口
  - 全局访问：TCP 端口22,80,443,18080（可选：用于在集群启动前查看并管理栈）
  - 节点间连接：
    - UDP 端口：500,4500
    - TCP 端口：2181,2376,2888,3888,6379
MySQL 数据库
- 至少 1GB 内存
- 每 Rancher Server 节点 50 连接（如：一个 3 节点的安装至少需要支持 150 连接）
外部负载均衡器

建议使用更大的部署

每个 Rancher Server 节点应该有 4GB 或 8GB 可用内存，意味着至少需要 8GB 或 16GB 的物理内存
MySQL 数据库应该使用高速的磁盘
对于真正的高可用，建议使用复制的 MySQL 并做适当的备份。由于存在事物锁，可以选择 Galera 或强制写入单节点的方式。

配置高可用(HA)的准备

根据使用外部数据库启动单节点说明部署一个至少拥有 1GB 内存的 MySQL 数据库，但是不要使用其中启动 Rancher Server 的相关指令。因为默认情况下，用户只能从本地访问数据库，你需要授权所有 Rancher Server 节点的网络。
配置一个外部负载均衡器并将端口 80 和 443 的流量指向运行 Rancher Server 的节点池。
使用这篇文档准备所有节点。这些节点都应该满足单节点部署 Rancher Server 的需求。（可选）您可以提前拉取 rancher/server 镜像到这些节点上。

目前，我们的高可用集群支持 3 种配置。 1 节点：没有高可用 3 节点：任何一台主机可以宕机 * 5 节点：任何两台主机可以宕机

注意：

这些节点可以分布在同一个地区并使用稳定的高速链路连接的多个数据中心，不建议分布在过大的区域。如果你选择分布节点在同一个区域，Zookeeper 可以保证集群的高可用。如果你的节点分布在不同的数据中心，那么你只能保留问题最少的那个区域。

在其中一个节点上，启动一个 Rancher Server 用于生成配置脚本。下面这个脚本用于生成 Rancher Server 同时连接到外部数据库并初始化数据。它将被引导高可用部署过程。最终，Rancher Server 容器将使用此步骤替换为支持高可用的 Rancher Server 容器。

$ sudo docker run -d -p 8080:8080 \
-e CATTLE_DB_CATTLE_MYSQL_HOST=<hostname or IP of MySQL instance> \
-e CATTLE_DB_CATTLE_MYSQL_PORT=<port> \
-e CATTLE_DB_CATTLE_MYSQL_NAME=<Name of Database> \
-e CATTLE_DB_CATTLE_USERNAME=<Username> \
-e CATTLE_DB_CATTLE_PASSWORD=<Password> \
-v /var/run/docker.sock:/var/run/docker.sock \
rancher/server:v1.0.1

注意：

请耐心等待，这个初始化步骤可能要15分钟才能完成

（可选）预先抓取 rancher/server 镜像到 Rancher 节点。这里抓取的镜像可用于配置脚本生成 Rancher Server 。
1
2
# The version would be whatever was used in Step 4
$ sudo docker pull rancher/server:v1.0.1

生成配置脚本

访问 Rancher Server 地址 http://<server_IP>:8080 生成脚本。在 Admin -> HA 确认 Rancher Server 已经成功连接到外部数据库。如果没有正确配置，请重复上一节中的步骤 1 和 4 。
选择集群大小，应该为您的 Rancher Server 节点数量，参照上一节中步骤 3 。
在 Host Registration URL 中填写外部负载均衡器的 IPv4 地址或主机名。
选择您想使用的证书类型。Rancher Server 可以为您生成一个自签名证书或者使用自己的有效证书。
点击 Generate Config Script 。
下载脚本并保存到本地。
保存脚本后，停止用于生成脚本的 Rancher Server 容器。

启动高可用的 Rancher

为了使所有节点支持高可用，你需要在所有节点上使用配置脚本启动 Rancher Server 。脚本将启动一个 Rancher Server 容器并连接到之前创建的外部数据库。

注意：

请确保您已经停止用于生成脚本 rancher-ha.sh 的 Rancher Server 容器后再运行配置脚本。否则，在你尝试在同一个节点运行配置脚本时，将会有一个端口冲突导致高可用节点无法启动。
如果你之前生成配置脚本时提供了 Host Registration URL ，请导航到外部负载均衡器的 IP 或主机名。请注意，Rancher Server 的用户界面可能需要几分钟才可以使用。如果你的用户界面仍不可用，请参照查看并管理栈。
一旦用户界面可用，您将可以添加主机到 Rancher 高可用集群。在 Admin -> HA 标签可以查看高可用节点的数量。添加主机前，您需要保存证书 /var/lib/rancher/etc/ssl/ca.crt 并赋予 400 权限到您要添加的主机上。注册命令可以自动创建使用并管理证书。
在您向环境中添加主机后，高可用设置已经完成，您可以开始通过用户界面添加服务，从 Catalog 启动模板或使用 rancher-compose 启动服务。

注意：

如果您正在使用 AWS ，你需要为添加到 Rancher 的主机配置 IP 。如果你想添加自定义主机，你需要在配置页面中填写公网 IP ，启动 Rancher agent 的命令会相应改变。已经通过页面添加的主机，必须 ssh 登陆到机器重启 Rancher agent 使 IP 生效。

From： http://docs.rancher.com/rancher/installing-rancher/installing-server/multi-nodes/

Zabbix邮件报警脚本

2016-04-30T16:00:00.000Z

Zabbix安装教程请移步 Zabbix Install
zabbix邮件报警配置步骤说明：

1、准备一个发送邮件的脚本

2、修改zabbix配置文件中指定的脚本路径

3、关联脚本名称

4、用户设置收件邮箱与报警时间

5、配置报警触发器

6、添加多个用户，同时给多个人发邮件

7、邮件接收测试

1、发送邮件的脚本

#!/usr/bin/python
# -*- coding:utf-8 -*-
# author:Strong It
# send zabbix message by email,usage: ./zabbix_email.py 收件人 标题 邮件内容

import smtplib
import sys
import time
from email.MIMEText import MIMEText
from email.Header import Header
from email.utils import parseaddr, formataddr
from email import encoders
reload(sys)
sys.setdefaultencoding('utf8')
current_time=time.strftime('%Y-%m-%d  %H:%M',time.localtime(time.time()))
  
mail_host ='smtp.exmail.qq.com'
mail_user ='Strong It@*****.com'
mail_pwd = '*****'

#地址格式化函数
def _format_addr(s):
    name, addr = parseaddr(s)
    return formataddr(( \
        Header(name, 'utf-8').encode(), \
        addr.encode('utf-8') if isinstance(addr, unicode) else addr))

#发送邮件函数
def send_email( content,mailto, get_sub ):
    msg = MIMEText( content,_subtype = 'plain', _charset = 'utf-8')
    #msg = MIMEText(content,_subtype='plain',_charset='gb2312')
    msg['From'] = _format_addr(u'Zabbix监控 <%s>' % mail_user)
    msg['Subject'] = _format_addr(u'报警信息 <%s>' % get_sub)
    msg['To'] = ",".join( mailto )  #多邮件账号格式用,分开
    try:
        s = smtplib.SMTP_SSL( mail_host, 465)       
        #s = smtplib.SMTP( mail_host, 25)       
        s.login(mail_user, mail_pwd )
        s.sendmail(mail_user, mailto,msg.as_string())
        s.close()
    except Exception as e:
        return 'Exception: ', e

#注意以下格式对齐
title = sys.argv[2]
cont = """
---------------------------------
摘要：  
%s
---------------------------------
时间：  %s
---------------------------------
  
"""%(sys.argv[3],current_time)
  
to_list = [
         '%s'%(sys.argv[1]),
        ]

#发送邮件的日志记录到/tmp/sendmail.log
with open('/tmp/sendmail_qs.log','ab') as f:
    f.write('%s  Receive address:  %s Title: %s \n'%(current_time,sys.argv[1],title))

if __name__ == '__main__':
    send_email( cont, to_list, title)

脚本名称：zabbix_email.py，使用格式：./zabbix_email.py 收件人标题邮件内容

2、更改zabbix配置文件的脚本路径

[root@zabbix alertscripts]# cat /etc/zabbix/zabbix_server.conf |grep AlertScriptsPath
### Option: AlertScriptsPath
# AlertScriptsPath=${datadir}/zabbix/alertscripts
AlertScriptsPath=/usr/lib/zabbix/alertscripts

3、关联脚本名称

【Administration –> Media types】

4、用户设置收件邮箱与报警时间

【Administration –> Users】

5、配置报警触发器

【Configuration –> Actions】

6、添加多个用户，同时给多个人发邮件

【Administration –> Users】

7、接收邮件报警测试

至此，Zabbix邮件告警已完成。

单节点服务器安装

2016-04-27T16:00:00.000Z

Rancher 使用基于 Docker 容器的部署方式。仅需简单的启动两个容器即可运行。一个容器用于管理 Rancher 服务，其他容器使用代理的方式管理主机或节点。

需求

任何支持 Docker 1.10.3 的 Linux 发行版。而 RancherOS，Ubuntu，RHEL/CentOS 7 经过了更多测试
1GB 内存
MySQL 服务，并且设置 max_connections > 150

启动 Rancher 服务器

在安装了 Docker 的服务器上可以很简单的使用命令启动 Rancher 服务

1	$ sudo docker run -d --restart=always -p 8080:8080 rancher/server

RANCHER UI

Rancher 的 UI 和 API 将开放 8080 端口。Docker 镜像下载后，还需要 1-2 分钟才可以成功启动并显示页面。

访问以下地址：http://<SERVER_IP>:8080，这里<SERVER_IP>是指运行 Rancher 服务并可用于访问的IP地址。

一旦 UI 处于启动和运行状态，就可以开始添加主机。主机添加到 Rancher 后，您可以开始添加服务或使用 Rancher catalog 启动模板。

开启活动目录或 OpenLDAP 支持(TLS)

为了开启 Rancher 活动目录或 OpenLDAP 支持(TLS)，Rancher Server 容器在启动时需要加载证书。您需要在运行 Rancher Server 的 Linux 主机上保存证书。

启动 Rancher 服务并使用绑定挂载卷的方式加载证书，证书在容器中必须使用ca.crt命名。

1 2	$ sudo docker run -d --restart=always -p 8080:8080 \ -v /dir_that_contains_the_cert/cert.crt:/ca.crt rancher/server

您可以通过检查 Rancher Server 容器日志确认ca.crt已经成功传递给 Rancher。

1	$ docker logs <server_container_id>

在日志的开始，会提示证书 ca.crt 已经添加。

DEFAULT_CATTLE_RANCHER_COMPOSE_WINDOWS_URL=https://releases.rancher.com/compose/beta/latest/rancher-compose-windows-386.zip
Adding ca.crt to Certs.
Updating certificates in /etc/ssl/certs... 1 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d....
done.
done.
[BOOTSTRAP] Starting Cattle

绑定挂载 MYSQL 卷

如果你想将容器内数据库持久化在主机上，可以在启动 Rancher Server 时绑定并挂载 MySQL 卷。

1	$ sudo docker run -d -v <host_vol>:/var/lib/mysql --restart=always -p 8080:8080 rancher/server

使用这个命令，数据库将持久化在主机上。如果您是一个已有的 Rancher 容器，请参照我们的升级文档。

使用外部数据库

如果您更希望使用外部数据库运行 Rancher Server ，请参照如下操作连接 Rancher 到数据库。您需要一个已经创建好的数据库，但是不需要创建任何数据库对象，Rancher 将会自动创建所有相关的数据库对象。

以下环境变量需要通过docker run命令启动 Rancher Server 来支持外部数据库。

CATTLE_DB_CATTLE_MYSQL_HOST: 数据库实例的主机名或IP地址
CATTLE_DB_CATTLE_MYSQL_PORT: 3306
CATTLE_DB_CATTLE_MYSQL_NAME: 数据库名
CATTLE_DB_CATTLE_USERNAME: 用户名
CATTLE_DB_CATTLE_PASSWORD: 密码

注意：

数据库名称和用户必须已经存在，Rancher 不会创建数据库。

这是一个用于创建数据库和用户的 SQL 命令。

sql CREATE DATABASE IF NOT EXISTS cattle COLLATE = 'utf8_general_ci' CHARACTER SET = 'utf8'; GRANT ALL ON cattle.* TO 'cattle'@'%' IDENTIFIED BY 'cattle'; GRANT ALL ON cattle.* TO 'cattle'@'localhost' IDENTIFIED BY 'cattle';

创建数据库和用户后，使用环境变量启动 Rancher Server。

$ sudo docker run -d --restart=always -p 8080:8080 \
    -e CATTLE_DB_CATTLE_MYSQL_HOST=<hostname or IP of MySQL instance> \
    -e CATTLE_DB_CATTLE_MYSQL_PORT=<port> \
    -e CATTLE_DB_CATTLE_MYSQL_NAME=<Name of Database> \
    -e CATTLE_DB_CATTLE_USERNAME=<Username> \
    -e CATTLE_DB_CATTLE_PASSWORD=<Password> \
    rancher/server

使用 HTTP 代理环境启动 Rancher Server

为了使用 HTTP 代理，需要修改 Docker 服务支持代理。在 Rancher Server 启动前，编辑/etc/defalut/docker文件指定您的代理并重新启动 Docker 服务。

1	$ sudo vi /etc/default/docker

在这个文件中编辑#export http_proxy="http://127.0.0.1:3128/"指向您的代理。保存修改并重新启动Docker服务，每个操作系统重新启动Docker服务的方式是不同的。

注意：

如果您使用 systemd 运行 Docker ，请参照 Docker 文档配置 HTTP 代理。

为了加载 Rancher catalog ，需要在启动 Rancher Server 时加载 HTTP 代理的环境变量信息。

$ sudo docker run -d \
    -e http_proxy=<proxyURL> \
    -e https_proxy=<proxyURL> \
    -e no_proxy="localhost,127.0.0.1" \
    --restart=always -p 8080:8080 rancher/server

如果不使用 Rancher catalog ，则使用正常方式运行启动 Rancher Server 命令。

在 Rancher 中添加主机，无需使用 HTTP 代理。

From： http://docs.rancher.com/rancher/installing-rancher/installing-server/

First Of My Hexo Blog

2016-04-22T16:00:00.000Z

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

以上是hexo第一篇默认内容，hexo出自台湾大学生tommy351之手,是由Node.js驱动的一款快速、简单且功能强大的博客框架。Node.js是一个可以快速构建网络服务及应用的平台，nvm是Node.js的版本控制工具。

安装Hexo

平台：Centos6.5 git1.8

# 安装nvm
$ curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh | bash
或
$ wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh | bash
或
$ git clone https://github.com/creationix/nvm.git ~/.nvm && cd ~/.nvm && git checkout `git describe --abbrev=0 --tags`
$ echo "export NVM_DIR="$HOME/.nvm"" >> ~./bashrc && echo "[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" # This loads nvm" >> ~./bashrc
# 使用Node.js
$ nvm install v5.10.1 && nvm alias default v5.10.1 && nvm use 5.10.1

下面安装hexo及相关插件：

$ npm install hexo -g
$ npm install hexo-generator-index --save
$ npm install hexo-generator-archive --save
$ npm install hexo-generator-category --save
$ npm install hexo-generator-tag --save
$ npm install hexo-server --save
$ npm install hexo-deployer-git --save
$ npm install hexo-deployer-heroku --save
$ npm install hexo-deployer-rsync --save
$ npm install hexo-deployer-openshift --save
$ npm install hexo-renderer-marked@0.2 --save
$ npm install hexo-renderer-stylus@0.2 --save
$ npm install hexo-generator-feed@1 --save
$ npm install hexo-generator-sitemap@1 --save

初始化

$ hexo init Myblog #初始化 
$ .
$ ├── _config.yml
$ ├── db.json
$ ├── node_modules
$ ├── package.json
$ ├── public
$ ├── scaffolds
$ ├── source
$ └── themes
$ hexo new [layout] <title>  #创建新文章，默认layout是post

文章摘要

在需要显示摘要的地方添加如下代码即可：

1
2
3

$ 以上是摘要
$ <!--more-->
$ 以下是余下全文

文章中插入图片

对于hexo，使用本地路径：在/source目录下新建一个img文件夹，将图片放入该文件夹下，插入图片时链接即为/img/图片名称。

More info: Writing

Run server

1	$ hexo server

More info: Server

Generate static files

1	$ hexo generate

More info: Generating

Deploy to remote sites

$ hexo deploy
$ [root@myou _posts]# tail -6 ../../_config.yml 
$ # Deployment
$ ## Docs: https://hexo.io/docs/deployment.html
$ deploy:
$   type: git
$   repo: https://github.com/strongit/strongit.github.io
$   branch: master

More info: Deployment

EMOS的安装与使用

2016-04-22T16:00:00.000Z

EMOS是一个基于CentOS，集成了ExtMail Server全部组件的小型Linux系统，10分钟即可完成安装及配置，成为完备的企业邮局系统。它的诞生将彻底改变邮件系统复杂的安装和配置局面，使只具备基本linux知识的用户就可轻松架设邮局。

获取软件

百度云盘地址：

EMOS 访问密码：lcr4

yum安装方式：

[root@emos /]# vi /etc/yum.repos.d/EMOS-Base.repo
# EMOS-Base.repo
#
# Created by ExtMail Dev Team: http://www.extmail.org/
#
# $Id$

[EMOS-base]
name=EMOS-Base
baseurl=http://mirror.extmail.org/yum/emos/1.5/os/$basearch/
gpgcheck=0
priority=0
protect=0

[EMOS-update]
name=EMOS-Updates
baseurl=http://mirror.extmail.org/yum/emos/1.5/updates/$basearch/
gpgcheck=0
priority=0
protect=0

保存后，然后尝试执行一下yum list 等操作，看看是否已经成功；

使用技巧：

安装过程很简单，以下是使用过后觉得可以优化的地方：

webmail中设置显示默认域名，不显示ip

[root@emos /]# vi /var/www/extsuite/extmail/html/default/index.html
156                 <TD><%password%></TD>
157                 <TD><INPUT TYPE="password" class="input_n" NAME="password"></TD>
158         </TR>
159         <TR>
160                 <TD><%domain%></TD>
161                 <TD><INPUT TYPE="text" class="input_n" NAME="domain" value="域名"></TD>

官方wiki

Main Page
forum