Apache/lighttpd: 相当于一个request proxy，根据配置，把不同的请求转发给不同的server处理，例如静态的文件请求自己处理，这个时候它就像一个web server，对于fastcgi/python这样的请求转发给flup这样的Server/Gateway进行处理

flup: 一个用python写的web server，也就是cgi中所谓的Server/Gateway，它负责接受apache/lighttpd转发的请求，并调用你写的程序 (application)，并将application处理的结果返回到apache/lighttpd

fastcgi: apache/lighttpd的一个模块，虽然flup可以作为一个独立的web server使用，但是对于浏览器请求处理一般都交给 apache/lighttpd处理，然后由apache/lighttpd转发给flup处理，这样就需要一个东西来把apache/lighttpd跟flup联系起来，这个东西就是fastcgi，它通过环境变量以及socket将客户端请求的信息传送给flup并接收flup返回的结果

web.py: 应该说有了上面的东西你就可以开始编写你的web程序了，但是问题是你就要自己处理浏览器的输入输出，还有cookie、session、模板等各种各样的问题了，web.py的作用就是帮你把这些工作都做好了，它就是所谓的web framework，另外一个出名的是django，不过感觉太复杂了，web.py差不多就够用了

WSGI : 除了flup Server/Gateway外还有很多其他人的写的Server/Gateway, 这个时候就会出问题了，如果你在flup上写了一个程序，现在由于各种原因你要使用xdly了，这个时候你的程序也许就要做很多痛苦的修改才能使用 xdly server了，WSGI就是一个规范，他规范了flup这个服务应该怎么写，应该使用什么方式什么参数调用你写的程序(application)等，当然同时也规范你的程序应该怎么写了，这样的话，只要flup跟xdly都遵守WSGI的话，你的程序在两个上面都可以使用了，flup就是一个WSGI server

转自豆瓣网

<embed play="true" quality="best" height="500" width="500" src="FLASH'S URL" pluginspage="http://www.macromedia.com/go/getflashplayer"></embed>

插入音乐文件:

<embed loop="false" autostart="false" controls="ImageWindow" maxwidth="500" src="AUDIOURL"></embed>

媒体标签介绍:
图文并茂的帖子还需要有音乐、影像等媒体做衬托，帖子的整体效果才达到极致。虽然论坛一般都提供插入媒体文件的方法，但那是很有局限的，并不能满足特殊的要求。为此，有必要学习和掌握媒体标签的使用方法。

首先我们先了解一下三种主要的音乐格式。这些音乐格式都是当前网络上较为流行的，它们更被广泛地应用于论坛。

出于编写代码的要求，我们这里以支持这些音乐的播放机为划分音乐格式的依据，这种划分方法以前也是有人使用过的。

第一种：WMP格式。

WMP即为Windows Media Player的缩写，是微软公司的媒体播放机，它集成在Windows系统里，可以格外免费升级（网上一般都有下载链接）。其网络ActiveX插件为 Windows Media Player。当前WMP所支持的音乐及影像媒体文件的格式主要有（仅介绍网络上常用的格式，下同）：

MP3（音频）、WMA（音频）、WMV（视频）、AVI（视频）、MPEG（电影）、WAV（音频）、MIDI（音频）、ASF（视频）、AIFF（音频）、AU（音频）、wpl文件（WMP播放列表文件）、m3u文件（Winamp的播放列表文件）等。

第二种：RP格式。

这是有着悠久历史的一种媒体格式，宽带普及以前的网络媒体文件的老大，由RealNetworks公司开发。它当前的网络ActiveX插件是Real Player G2 Control。常见文件后缀名为：

rax、ram、rmm、rsml、rvx、rmj、rmx、rjt、rm

REAL也支持MP3、MIDI、Wav等格式的媒体文件，但它的播放效果没有WMP的好，所以我们不把它列入RP格式。

第三种：Flash格式。这是Macromedia公司开发的结合音频视频在一块的媒体格式。其插件为Shock Wave。文件后缀名为.swf。

弄清楚以上文件格式后，我们就可以使用标签来编写播放媒体文件的代码了。语法：

格式一：

格式二：

格式一适用于显示播放界面的情形，格式二适用于隐藏播放界面的情形。

下面分别讲解各参数的取值规定和要求。

src：媒体音乐地址。地址要完整、有效。如果文件名包含非英文字符，建议整个地址用小角双引号引起来。

autostart：是否自动播放（即一打开帖子就播放与否）。true为自动，false为手动。

loop:是否循环播放。true为循环，false只播放一次；也可用正整数表示播放多少次，比如等于3表示播放3次。

width:播放界面的宽度。建议在300到500之间。

height:播放界面的度度。这个很讲究。针对音频文件，视频界面是没有必要出现的，为此，WMP播放机设置为45非常合适，RP播放机为85较好；有视频的则根据情况设置。

hidden:是否隐藏播放界面。格式二语法式样中设置为true，即不可见，如果设置为false，则表示可见，但若不设置width和 height，它的样子是不好看的。有不少人也用width=0 height=0来隐藏播放机的播放界面，其是这样是隐藏不了的，WMP有一个点，RP有一条竖线。

type:这是一个重要的值，用于指播放机的插件类型，一些论坛会根据有效的src自动给出type类型（这类论坛我们编写代码时可以省略type），但也有的论坛不会自动给出类型，需要用户指定。type的取值依据和取值规定是：

WMP类：audio/mpeg (wma的可用audio/x-ms-wma，不过都一样)

RP类：application/octet-stream

Flash：application/x-shockwave-flash

注：Flash还可指定wmode=transparent表示背景透明，quality=high表示以高档画质播放，pluginspage=http://www.macromedia.com/go/getflashplayer指定插件下载地址（可省略）。

类型的指定尽量不要弄错，否则极可能出现有些朋友访问你的帖子时不能正常欣赏到音乐和影像媒体。

对于支持object的论坛，建议使用object来播放媒体文件，它得到的效果更能令人满意。因其代码较多，不便记忆，这里就不介绍了，但你可以通过FP或DW插入Web组件的方法并对ActiveX控件进行相应的设置得到完整的代码。
原文地址:http://www.a18zhizao.cn/y2008/99_在wordpress中插入flash和音乐文件无需插件.html

如果路径被篡改，可以在地址栏输入“about:cache”命令回车，查看临时文件所在的具体位置。我们也能自己修改Firefox临时文件的存放路径：新建一个标签页在地质栏中输入“about:config”回车，在Config列表中点击右键，选择“新建→字符串”，在弹出的“新的字符串值”对话框“首选项名称”中输入“browser.cache.disk.parent_directory”确定，在下个窗口中输入字符串的值，即新的文件路径，确定后在Config列表中看到新建的这个字符串，并可以随时修改这个值改变路径

本文转载自互联网,原文地址:http://www.cnblogs.com/qlight/archive/2008/09/20/1294923.html

这是Wordpress的一个bug，在某些文件系统上有问题从wordpress2.5到2.7都一直没有更新，在国外网站上查了下修复方法如下：

1. 编辑wp-admin/includes/file.php找到以下这行
if(getmyuid()==fileowner($tempFile)){
把这句中把getmyuid改成posix_getuid

2. 完成以上修改应该不会再要输入ftp信息了，但是有时候会告知目录不对，在wp-content目录下建立upgrade目录
chown www:www wp-content/upgrade
chmod +w wp-content/upgrade
做完以上设置应该就可以自动更新了。

转载地址http://blogsdiy.org/2007-12/wordpress-template-handbook

Header部分常用到的PHP函数

<? php bloginfo('name'); ?>	博客名称(Title)
<? php bloginfo('stylesheet_url'); ?>	CSS文件路径
<? php bloginfo('pingback_url'); ?>	PingBack Url
<? php bloginfo('template_url'); ?>	模板文件路径
<? php bloginfo('version'); ?>	WordPress版本
<? php bloginfo('atom_url'); ?>	Atom Url
<? php bloginfo('rss2_url'); ?>	RSS 2.o Url
<? php bloginfo('url'); ?>	博客 Url
<? php bloginfo('html_type'); ?>	博客网页Html类型
<? php bloginfo('charset'); ?>	博客网页编码
<? php bloginfo('description'); ?>	博客描述
<? php wp_title(); ?>	特定内容页(Post/Page)的标题

模板常用的PHP函数及命令

<? php get_header(); ?>	调用Header模板
<? php get_sidebar(); ?>	调用Sidebar模板
<? php get_footer(); ?>	调用Footer模板
<? php the_content(); ?>	显示内容(Post/Page)
<? php if(have_posts())	?>	检查是否存在Post/Page
<? php while(have_posts())	the_post(); ?>	如果存在Post/Page则予以显示
<? php endwhile; ?>	While 结束
<? php endif; ?>	If 结束
<? php the_time('字符串') ?>	显示时间，时间格式由“字符串”参数决定，具体参考PHP手册
<? php comments_popup_link(); ?>	正文中的留言链接。
    如果使用 comments_popup_script()，则留言会在新窗口中打开，反之，则在当前窗口打开
<? php the_title(); ?>	内容页(Post/Page)标题
<? php the_permalink() ?>	内容页(Post/Page) Url
<? php the_category(', ') ?>	特定内容页(Post/Page)所属Category
<? php the_author(); ?>	作者
<? php the_ID(); ?>	特定内容页(Post/Page) ID
<? php edit_post_link(); ?>	如果用户已登录并具有权限，显示编辑链接
<? php get_links_list(); ?>	显示Blogroll中的链接
<? php comments_template(); ?>	调用留言/回复模板
<? php wp_list_pages(); ?>	显示Page列表
<? php wp_list_categories(); ?>	显示Categories列表
<? php next_post_link(' %link '); ?>	下一篇文章链接
<? php previous_post_link('%link'); ?>	上一篇文章链接
<? php get_calendar(); ?>	日历
<? php wp_get_archives() ?>	显示内容存档
<? php posts_nav_link(); ?>	导航，显示上一篇/下一篇文章链接
<? php include(TEMPLATEPATH . '/文件名'); ?>	嵌入其他文件，可为定制的模板或其他类型文件

与模板相关的其他函数

<? php _e('Message'); ?>	输出相应信息
<? php wp_register(); ?>	显示注册链接
<? php wp_loginout(); ?>	显示登录/注销链接
< !-- next page -->	将当前内容分页
< !-- more -->	将当前内容截断，以不在主页/目录页显示全部内容
<? php timer_stop(1); ?>	网页加载时间(秒)
<? php echo get_num_queries(); ?>	网页加载查询量

安装流程:下载、上传、激活、插入代码

1、下载   Paginator 3000

2、解压后上传到wp-content\plugins目录里面

3、进入管理后台选择插件—>已安装—->Paginator—->启用

4、修改主题的index.php页面,找到div class=”navigation”后按下面代码修改

<div class="navigation">
<?php if(function_exists('wp_paginator')) { wp_paginator(); } ?>
<?php if(function_exists('wp_pagenavi')) : { wp_pagenavi(); } ?>
<?php else : ?>
<?php endif; ?>
</div>

Hosting24旗下的000webhost，自称“比收费虚拟主机更好”的免费空间，他的口碑也确实不错。免费提供1500M空间，100G流量，FTP、Web方式上传管理文件，支持PHP5，提供2个MySQL数据库，功能强大的cPanel管理面板，管理面板中可一键安装WordPress、phpBB2、Drupal、Joomla等几种热门PHP程序，免费提供1个二级域名，可以绑定自己的域名，速度不错，无广告。但需要使用VPN代理才能成功申请。

网址：http://www.000webhost.com

MySQL数据库创建过程：
登陆后台，进入“Go to CPanel”，再点“MySQL”中进入。依次输入数据库名、数据库用户名、数据库用户密码和确认密码，点下面的按钮创建数据库。然后会给出MySQL 服务器地址，一般是“mysqlN.000webhost.com”这样的地址，不是localhost。

一键安装程序：
进入“Fantastico Autoinstaller”，点你要选择安装程序下面的“New Installation”按钮，然后输入要安装到的目录名称以及管理用户名和密码。然后回到前面的一键安装页面，点“View Installation Details”按钮查看管理地址和用户信息。

绑定域名：
进入“Parked Domains”，输入你的域名点下面的按钮绑定到你的免费空间上，再设置你的域名解析到你的空间上即可。可以修改你的域名DNS 为：ns01.000webhost.com和ns02.000webhost.com，或者设置你的域名CNAME别名解析到000webhost提供给你的免费二级域名，也可以设置A记录解析到你的000webhost二级域名的IP地址，CNAME和A记录解析比修改DNS会快很多。

000webhost的FAQ帮助：http://www.000webhost.com/faq.php

将

<?php the_category('/',''); ?>

换成

<?php

foreach((get_the_category()) as $category) { 
    echo $category->cat_name . ' '; 
} 
?>

vi wordpress.conf

if (-f $request_filename/index.html){
rewrite (.*) $1/index.html break;
}
if (-f $request_filename/index.php){
rewrite (.*) $1/index.php;
}
if (!-f $request_filename){
rewrite (.*) /index.php;
}

server {
listen 80;
server_name www.aaronw.cn;
index index.html index.php;
include wordpress.conf;

一定要加在这里，我开始加在location里面发现它不生效。 Nginx重定向[Rewrite]配置及示例
首先Apache的Rewite规则差别不是很大,但是Nginx的Rewrite规则比Apache的简单灵活多了 Nginx可以用if进行条件匹配，语法规则类似C

if ($http_user_agent ~ MSIE) { rewrite ^(.*)$ /msie/$1 break; }

官方文档请点击这里
Rewrite的Flags

Flags can be any of the following:
* last – completes processing of rewrite directives, after which searches for corresponding URI and location
* break – completes processing of rewrite directives
*redirect – returns temporary redirect with code 302; it is used if the substituting line begins with http://
* permanent – returns permanent redirect with code 301

last – 完成重写指令后，搜索相应的URI和位置。相当于Apache里的[L]标记，表示完成rewrite，不再匹配后面的规则。
break – 中止Rewirte，不在继续匹配。
redirect – 返回临时重定向的HTTP状态302。
permanent – 返回永久重定向的HTTP状态301。

ZEND Framework的重定向规则：
案例一：
全部重定向到 /index.php

rewrite ^/(.*) /index.php?$1&;

案例二： 如果文件或目录不存在则重定向到index.php

if (!-e $request_filename) { rewrite ^/(.*) /index.php?$1&; }

Wordpress的重定向规则：
案例一： http://www.abc.com/12 重定向到http://www.abc.com/index.php?p=12

if (!-e $request_filename) { rewrite ^/(.+)$ /index.php?p=$1 last; }

案例二： 与zendframework配置很像

if (!-e $request_filename) { rewrite ^/(.*) /index.php?$1&; }

以下为Discuz完整的Rewrite for Nginx规则

if (!-f $request_filename) {
rewrite ^/archiver/((fid|tid)-[\w\-]+\.html)$ /archiver/index.php?$1 last;
rewrite ^/forum-([0-9]+)-([0-9]+)\.html$ /forumdisplay.php?fid=$1&page=$2 last;
rewrite ^/thread-([0-9]+)-([0-9]+)-([0-9]+)\.html$/viewthread.php?tid=$1&extra=page%3D$3&page=$2 last;
rewrite ^/space-(username|uid)-(.+)\.html$ /space.php?$1=$2 last;
rewrite ^/tag-(.+)\.html$ /tag.php?name=$1 last; }

文件及目录匹配，其中：
-f和!-f用来判断是否存在文件
-d和!-d用来判断是否存在目录
-e和!-e用来判断是否存在文件或目录
-x和!-x用来判断文件是否可执行

正则表达式全部符号解释
~ 为区分大小写匹配
~* 为不区分大小写匹配
!~和!~* 分别为区分大小写不匹配及不区分大小写不匹配
(pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ‘\(’ 或 ‘\)’。
^ 匹配输入字符串的开始位置。
$ 匹配输入字符串的结束位置。

link rel="stylesheet" href="< ?php echo get_bloginfo('wpurl').'/wp-content/plugins/syntaxhighlighter/files/SyntaxHighlighter.css'; ?>" type="text/css" media="screen" />

      4、上述步骤完成后检查你使用主题的footer.php文件,看看其中是否有这个的语句<?php wp_footer(); ?>，如果没有则该插件的JavaScript 不能使用。

SyntaxHighlighter 的使用
      在遇到想用程序语法的时候，下面的方式择一使用：
   （红色的部分请选择相应的语言）

        您的程序代码
        您的程序代码
        您的程序代码
        您的程序代码
        您的程序代码
        您的程序代码
        您的程序代码
        您的程序代码
        您的程序代码
PHP范例

< ?php
define('ABSPATH', dirname(__FILE__).'/');<span class="MyColor1">< ?php wp_footer(); ?>
require_once(ABSPATH.'wp-settings.php');
?>

CSS范例

div.Test {
 width: 190px;
 font-size: 13px;
 font-family: Verdana, Serif;
} /* 测试 */

JavaScript范例

var a = 1;
var b = 5;
flag1 = new Boolean(a < b);
 document.write("1 < 5 是 " + flag1);
flag2 = new Boolean(a > b);
 document.write("1 > 5 是 " + flag2);

firebug-120b3

RED5启动的时候，在”webapps”目录的程序文件都是搜索”WEB-INF”的目录下的配置文件来完成配置的。

最主要的配置文件是”web.xml”。这个文件里包含了以下参数：

globalScope：指定全局作用范围

contextConfigLocation：指定配置handler的文件的位置。这些配置文件描述了客户端加入/离开的动作触发后调用的处理方法，作用范围。在描述的时候可以使用通配符来描述多个文件：

locatorFactorySelector：程序的根上下文，通常是”red5.xml”

parentContextKey：父级上下文，通常是”default.context”

log4jConfigLocation：日志配置文件的位置

webAppRootKey：程序的全局唯一名

对于每一个Handler配置文件最少需要有三个bean

Context：用来影射路径到某个作用范围、搜索服务和Handler，它有一个保留的名字”web.context”。 其默认的类为org.red5.server.Context

对于没有一个应用程序只应该有一个Context，但是同一个Context可以被多个作用范围共享

Scope：每一个应用程序最少有一个作用范围，用来将handler连接到context和服务器。作用范围可以建立一棵树，每一个客户端连接到树上的一个节点，而共享对象存在于作用范围里。可以把作用范围看作是聊天室或者程序实例。默认的作用范围通常是web.scope，不过这名字是可以任意取的。

对于bean有以下属性：

server：与全局服务器”red5.server”相关。

parent：指定当前作用范围的父范围，通常是”global.scope”

context：当前作用范围的服务器上下文，一般指定为”web.context”

handler：对应当前作用范围的handler

contextPath：用来连接到当前作用范围的路径

virtualHosts：一个主机名或IP的列表，用来描述虚拟主机的位置，列表项目之间用逗号分隔开。

为了应用程序配置方便的需要，可以将”contextPath“和”virtualHosts“放到另外一个单独的属性文件里边，而在这里使用变量来表示，为此需要添加一个特别的bean来指定属性文件的位置。

假设在属性文件red5-web.properties里有如下的数据：

则上边的bean的”contextPath“和”virtualHosts“属性即可使用变量来指定值

对于”contextPath“可以视为是一个根作用范围。你可以在配置好的”contextPath“路径后边随意添加其他的路径，而连接到这些路径的客户端将动态创建另外的作用范围，这些作用范围使用的是同样的handler，但拥有自己的属性、共享对象和活动流。

handler：每一个上下文需要一个handler来响应用户连接、离开作用范围时的动作，handler实现了很多方法，用户可以调用以达到特定的目的。这个 handler必须实现”org.red5.server.api.IScopeHandler“接口，当然针对共享对象和流的访问还应该实现其他的接口。

在”org.red5.server.adapter.ApplicationAdapter“可以找到一个能够用作基类的例子，同时还应该多多参照文档以得到更多细节。

某个作用范围的handler可以如下指定：

其中”id“属性是上边定义的作用范围里指定的。

如果你不需要任何服务端的逻辑处理，可以使用Red5默认提供的handler

handler的例子

这里假设使用上边的配置，则在客户端调用的时候使用以下方式

返回因该有输出：

The result is 3

RTMP协议和Http比有哪些优势呢，或者说：我们为什么要使用FMS/Red5呢？

两种协议HTTP和RTMP，有点点不同，
用HTTP方式：　先通过IIS 将FLV下载到本地缓存，然后再通过NetConnection的本地连接来播放这个FLV，这种方法是播放本地的视频，并不是播放服务器的视频。因此在 本地缓存里可以找到这个FLV。其优点就是服务器下载完这个FLV，服务器就没有消耗了，节省服务器消耗。其缺点就是FLV会缓存在客户端，对FLV的保 密性不好。
用RTMP方 式：　通过NetConnection连接到FMS/Red5服务器，并实时播放服务器的FLV文件，这种方式可以任意选择视频播放点（SEEK()）， 并不象HTTP方式需要缓存完整个FLV文件到本地才可以任意选择播放点，其优点就是在本地缓存里是找不到这个FLV文件的。其优点就是FLV不会缓存在 客户端，FLV的保密性好，其缺点就是消耗服务器资源，连接始终是实时的。
一句话，一个是本地播放，一个是服务器实时播放，因需而定。

HTTP现在应用的比较多，因为这个完全不需要RED5或者FMS的服务器端的支持，普通的WEB服务器都可以实现（虚拟主机）
后面一个就必须有服务器了，不过保密性会强一些。

只所以大多数站点都用HTTP模式，一个是因为对服务器来说压力小一些，另外一种对FLASH来讲，播放器的参数更容易设置一些，因为只要修改xxx.swf?file=xxx就可以了：）

二、基本命令
nginx –v 显示nginx的版本
[root@localhost sbin]# ./nginx -v
nginx version: nginx/0.5.34
nginx –V 显示nginx的版本，编译器和配置参数
[root@localhost sbin]# ./nginx -V
nginx version: nginx/0.5.34
built by gcc 3.4.6 20060404 (Red Hat 3.4.6-3)
configure arguments: –prefix=/usr/local/nginx_2 –with-http_stub_status_module
nginx –t 不运行，仅仅测试配置文件
nginx –c </path/to/config>为nginx指定配置文件
[root@localhost sbin]# ./nginx -t -c /usr/local/nginx_2/conf/nginx_status.conf
2008/01/26 18:34:40 [info] 4242#0: the configuration file /usr/local/nginx_2/conf/nginx_status.conf syntax is ok
2008/01/26 18:34:40 [info] 4242#0: the configuration file /usr/local/nginx_2/conf/nginx_status.conf was tested successfully

启动nginx
/usr/local/nginx_2/sbin/nginx –c /usr/local/nginx_2/conf/nginx_status.conf
注：如果不指定配置文件，系统会按照Nginx安装目录下conf/nginx.conf的配置启动。
退出nginx
kill –QUIT nginx_pid

三、配置文件
Nginx涉及到的配置文件
koi-utf koi-win mime.types mime.types.default nginx.conf nginx.conf.default win-utf
其中主配置文件是nginx.conf，主要的配置工作，都在这里进行
mime.types文件规定文件的类型
A）配置文件解释
nginx.conf文件
user www users; 规定用户、用户组
worker_processes 3; 规定工作进程数 默认是1
error_log logs/error.log;记录日志文件
pid logs/nginx.pid; 主进程的进程号
events {
use epoll; 规定使用的I/O复用模式
worker_connections 1024; 规定进程的连接数 默认是1024
}
最大客户端数由worker_processes、worker_connections决定
Max_client=worker_processes*worker_connections
在反向代理情况下
Max_client=worker_processes*worker_connections/4

http {
include conf/mime.types;
default_type application/octet-stream;
log_format main ‘$remote_addr – $remote_user [$time_local] $request ‘
‘”$status” $body_bytes_sent “$http_referer” ‘
‘”$http_user_agent” “$http_x_forwarded_for”‘;
#规定了日志的文件格式
access_log logs/access.log main;
keepalive_timeout 65;
server {
listen 80;
server_name localhost;
location / {
root html;
index index.html index.htm;
}
# redirect server error pages to the static page /50x.html
#
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}
B）带监控模块的配置
################状态监控######################
user www users;
worker_processes 3;
error_log logs/error.log;
pid logs/nginx.pid;
events {
use epoll;
worker_connections 1024;
}
http {
include conf/mime.types;
default_type application/octet-stream;
log_format main ‘$remote_addr – $remote_user [$time_local] $request ‘
‘”$status” $body_bytes_sent “$http_referer” ‘
‘”$http_user_agent” “$http_x_forwarded_for”‘;
access_log logs/access.log main;
keepalive_timeout 65;
server {
listen 80;
server_name localhost;
location / {
root html;
index index.html index.htm;
}
# redirect server error pages to the static page /50x.html
#
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
#######################状态监控部分############################
server{
listen 80;
server_name status.ceshi.com;
location / {
stub_status on;
access_log off;
}
}
}
C)虚拟主机的配置
###############虚拟主机配置文档#########################
user www users;
worker_processes 3;
error_log logs/error.log;
pid logs/nginx.pid;
events {
use epoll;
worker_connections 1024;
}
http {
include conf/mime.types;
default_type application/octet-stream;
log_format main ‘$remote_addr – $remote_user [$time_local] $request ‘
‘”$status” $body_bytes_sent “$http_referer” ‘
‘”$http_user_agent” “$http_x_forwarded_for”‘;
access_log logs/access.log main;
keepalive_timeout 65;
server {
listen 172.20.20.244;
listen 172.20.20.244:80;
server_name localhost;
location / {
root html;
index index.html index.htm;
}
# redirect server error pages to the static page /50x.html
#
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
######################虚拟主机部分####################
server {
listen 172.20.20.244;
listen 172.20.20.244:80;
listen 8000;
server_name [url]www.love.com[/url];
location / {
root www/love;
index index.html index.htm;
}
}
server {
listen 172.20.20.244;
listen 172.20.20.244:80;
listen 9000;
server_name [url]www.duzhenhua.com[/url];
location / {
root www/duzhenhua;
index index.html index.htm;
}
}
server {
listen 172.20.20.244;
listen 172.20.20.244:80;
listen 9900;
server_name [url]www.du.com[/url];
location / {
root www/du;
index index.html index.htm;
}
}
}

四、事件模型介绍–I/O复用方法
与apache相类，nginx针对不同的操作系统，有不同的事件模型
A）标准事件模型
Select、poll属于标准事件模型，如果当前系统不存在更有效的方法，nginx会选择select或poll
B）高效事件模型
Kqueue：使用于 FreeBSD 4.1+, OpenBSD 2.9+, NetBSD 2.0 和 MacOS X. 使用双处理器的MacOS X系统使用kqueue可能会造成内核崩溃。
Epoll: 使用于Linux内核2.6版本及以后的系统。
/dev/poll：使用于 Solaris 7 11/99+, HP/UX 11.22+ (eventport), IRIX 6.5.15+ 和 Tru64 UNIX 5.1A+。
Eventport：使用于 Solaris 10. 为了防止出现内核崩溃的问题， 有必要安装安全补丁。

五、关于LEMP的结构
A）Linux+Nginx+Mysql+Php
对于LEMP结构，网络上有人搭建了，整个搭建过程可以参考：
[url]http://blog.s135.com/read.php/314.htm[/url]。
如果考虑将此结构应用到实际项目中，还需要具体测试。
B）其他结构
我们大部分项目都是采用Linux+Apache+Mysql+Php，可以考虑在前端添加一个Nginx服务器，由它来处理大量静态页面，其它页面由原来系统处理。

六、软件的平滑升级
A）简单修改配置文件
当系统管理员需要修改配置文件时，不需要停机可以参考以下过程。
kill -HUP Nginx_root_PID
例如：
首先按照需要修改Nginx的配置文件，然后使用-t参数测试配置文件的正确性，一切验证无误，最后执行新的配置文件。
[root@localhost sbin]# ps -ef|grep nginx
root 4258 1 0 16:12 ? 00:00:00 nginx: master process ./nginx
www 4259 4258 0 16:12 ? 00:00:00 nginx: worker process
www 4260 4258 0 16:12 ? 00:00:00 nginx: worker process
www 4261 4258 0 16:12 ? 00:00:00 nginx: worker process
root 4264 4220 0 16:12 pts/0 00:00:00 grep nginx
[root@localhost sbin]# kill -HUP 4258
[root@localhost sbin]# ps -ef|grep nginx
root 4258 1 0 16:12 ? 00:00:00 nginx: master process ./nginx
www 4265 4258 0 16:14 ? 00:00:00 nginx: worker process
www 4266 4258 0 16:14 ? 00:00:00 nginx: worker process
www 4267 4258 0 16:14 ? 00:00:00 nginx: worker process
root 4269 4220 0 16:14 pts/0 00:00:00 grep nginx
B）平滑升级二进制代码
过程分析
首先，使用新的可执行程序替换旧的，然后，发送USR2（kill –USR2 ROOT_PID）信号给主进程，主进程将重新命名它的.pid文件为nginx.pid..oldbin,然后执行新的可执行程序，依次启动新的主进程和工作进程。
在这时，两个nginx实例会同时运行，一起处理输入的请求。需要逐步停止旧的实例，此时需要发送WINCH信号给就的主进程，然后它的工作进程开始关闭。
一段时间后，旧的工作进程处理了所有已连接的请求后退出，就仅由新的工作进程来处理输入的请求。
这时，因为旧的服务器还尚未关闭它监听的套接字，所以通过下面几步仍然可以恢复旧的服务器。
a) 发送HUP信号给旧的主进程，它将在不重载配置文件的情况下启动它的工作进程。
b) 发送QUIT信号给新的主进程，要求其从容关闭其工作进程
c) 发送TERM信号给新的主进程，迫使其退出
d) 如果新的工作进程不退，可以发送kill命令
e) 新的主进程退出后，会恢复nginx.pid.oldbin为nginx.pid。一切照旧。
如果升级成功，发送QUIT给旧的主进程。

七、相关的处理信号
A)主进程可以处理的信号
TERM ，INT 快速关闭
QUIT 从容关闭
HUP 重载配置，用新的配置开始新的进程，从容关闭旧的工作进程
USR1 重新打开日志文件
USR2 平滑升级可执行程序
WINCH 从容关闭工作进程
B)工作进程可以处理的信号
TERM ，INT 快速关闭
QUIT 从容关闭
USR1 重新打开日志文件

LiveJournal是99年始于校园中的项目，几个人出于爱好做了这样一个应用，以实现以下功能：

• 博客，论坛
• 社会性网络，找到朋友
• 聚合，把朋友的文章聚合在一起

LiveJournal采用了大量的开源软件，甚至它本身也是一个开源软件。在上线后，LiveJournal实现了非常快速的增长：

• 2004年4月份：280万注册用户。
• 2005年4月份：680万注册用户。
• 2005年8月份：790万注册用户。
• 达到了每秒钟上千次的页面请求及处理。
• 使用了大量MySQL服务器。
• 使用了大量通用组件。

二、LiveJournal架构现状概况

三、从LiveJournal发展中学习

LiveJournal从1台服务器发展到100台服务器，这其中经历了无数的伤痛，但同时也摸索出了解决这些问题的方法，通过对LiveJournal的学习，可以让我们避免LJ曾经犯过的错误，并且从一开始就对系统进行良好的设计，以避免后期的痛苦。

下面我们一步一步看LJ发展的脚步。

1、一台服务器

一台别人捐助的服务器，LJ最初就跑在上面，就像Google开始时候用的破服务器一样，值得我们尊敬。这个阶段，LJ的人以惊人的速度熟悉的Unix的操作管理，服务器性能出现过问题，不过还好，可以通过一些小修小改应付过去。在这个阶段里LJ把CGI升级到了FastCGI。

最终问题出现了，网站越来越慢，已经无法通过优过化来解决的地步，需要更多的服务器，这时LJ开始提供付费服务，可能是想通过这些钱来购买新的服务器，以解决当时的困境。
毫无疑问，当时LJ存在巨大的单点问题，所有的东西都在那台服务器的铁皮盒子里装着。

2、两台服务器

用付费服务赚来的钱LJ买了两台服务器：一台叫做Kenny的Dell 6U机器用于提供Web服务，一台叫做Cartman的Dell 6U服务器用于提供数据库服务。

LJ有了更大的磁盘，更多的计算资源。但同时网络结构还是非常简单，每台机器两块网卡，Cartman通过内网为Kenny提供MySQL数据库服务。

暂时解决了负载的问题，新的问题又出现了：

• 原来的一个单点变成了两个单点。
• 没有冷备份或热备份。
• 网站速度慢的问题又开始出现了，没办法，增长太快了。
• Web服务器上CPU达到上限，需要更多的Web服务器。

3、四台服务器

又买了两台，Kyle和Stan，这次都是1U的，都用于提供Web服务。目前LJ一共有3台Web服务器和一台数据库服务器。这时需要在3台Web服务器上进行负载均横。

LJ把Kenny用于外部的网关，使用mod_backhand进行负载均横。

然后问题又出现了：

• 单点故障。数据库和用于做网关的Web服务器都是单点，一旦任何一台机器出现问题将导致所有服务不可用。虽然用于做网关的Web服务器可以通过保持心跳同步迅速切换，但还是无法解决数据库的单点，LJ当时也没做这个。
• 网站又变慢了，这次是因为IO和数据库的问题，问题是怎么往应用里面添加数据库呢？

4、五台服务器

又买了一台数据库服务器。在两台数据库服务器上使用了数据库同步(Mysql支持的Master-Slave模式)，写操作全部针对主数据库（通过 Binlog，主服务器上的写操作可以迅速同步到从服务器上），读操作在两个数据库上同时进行(也算是负载均横的一种吧)。

实现同步时要注意几个事项：

• 读操作数据库选择算法处理，要选一个当前负载轻一点的数据库。
• 在从数据库服务器上只能进行读操作
• 准备好应对同步过程中的延迟，处理不好可能会导致数据库同步的中断。只需要对写操作进行判断即可，读操作不存在同步问题。

5、更多服务器

有钱了，当然要多买些服务器。部署后快了没多久，又开始慢了。这次有更多的Web服务器，更多的数据库服务器，存在 IO与CPU争用。于是采用了BIG-IP作为负载均衡解决方案。

6、现在我们在哪里：

现在服务器基本上够了，但性能还是有问题，原因出在架构上。

数据库的架构是最大的问题。由于增加的数据库都是以Slave模式添加到应用内，这样唯一的好处就是将读操作分布到了多台机器，但这样带来的后果就是写操作被大量分发，每台机器都要执行，服务器越多，浪费就越大，随着写操作的增加，用于服务读操作的资源越来越少。

由一台分布到两台

最终效果

现在我们发现，我们并不需要把这些数据在如此多的服务器上都保留一份。服务器上已经做了RAID，数据库也进行了备份，这么多的备份完全是对资源的浪费，属于冗余极端过度。那为什么不把数据分布存储呢？

问题发现了，开始考虑如何解决。现在要做的就是把不同用户的数据分布到不同的服务器上进行存储，以实现数据的分布式存储，让每台机器只为相对固定的用户服务，以实现平行的架构和良好的可扩展性。

为了实现用户分组，我们需要为每一个用户分配一个组标记，用于标记此用户的数据存放在哪一组数据库服务器中。每组数据库由一个master及几个 slave组成，并且slave的数量在2-3台，以实现系统资源的最合理分配，既保证数据读操作分布，又避免数据过度冗余以及同步操作对系统资源的过度消耗。

由一台（一组）中心服务器提供用户分组控制。所有用户的分组信息都存储在这台机器上，所有针对用户的操作需要先查询这台机器得到用户的组号，然后再到相应的数据库组中获取数据。

这样的用户架构与目前LJ的架构已经很相像了。

在具体的实现时需要注意几个问题：

• 在数据库组内不要使用自增ID，以便于以后在数据库组之间迁移用户，以实现更合理的I/O，磁盘空间及负载分布。
• 将userid，postid存储在全局服务器上，可以使用自增，数据库组中的相应值必须以全局服务器上的值为准。全局服务器上使用事务型数据库InnoDB。
• 在数据库组之间迁移用户时要万分小心，当迁移时用户不能有写操作。

7、现在我们在哪里

问题：

• 一个全局主服务器，挂掉的话所有用户注册及写操作就挂掉。
• 每个数据库组一个主服务器，挂掉的话这组用户的写操作就挂掉。
• 数据库组从服务器挂掉的话会导致其它服务器负载过大。

对于Master-Slave模式的单点问题，LJ采取了Master-Master模式来解决。所谓Master-Master实际上是人工实现的，并不是由MySQL直接提供的，实际上也就是两台机器同时是Master，也同时是Slave，互相同步。

Master-Master实现时需要注意：

• 一个Master出错后恢复同步，最好由服务器自动完成。
• 数字分配，由于同时在两台机器上写，有些ID可能会冲突。

解决方案：

• 奇偶数分配ID，一台机器上写奇数，一台机器上写偶数
• 通过全局服务器进行分配(LJ采用的做法)。

Master-Master模式还有一种用法，这种方法与前一种相比，仍然保持两台机器的同步，但只有一台机器提供服务（读和写），在每天晚上的时候进行轮换，或者出现问题的时候进行切换。

8、现在我们在哪里

现在插播一条广告，MyISAM VS InnoDB。

使用InnoDB：

• 支持事务
• 需要做更多的配置，不过值得，可以更安全的存储数据，以及得到更快的速度。

使用MyISAM：

• 记录日志（LJ用它来记网络访问日志）
• 存储只读静态数据，足够快。
• 并发性很差，无法同时读写数据（添加数据可以）
• MySQL非正常关闭或死机时会导致索引错误，需要使用myisamchk修复，而且当访问量大时出现非常频繁。

9、缓存

去年我写过一篇文章介绍memcached，它就是由LJ的团队开发的一款缓存工具，以key-value的方式将数据存储到分布的内存中。LJ缓存的数据：

• 12台独立服务器（不是捐赠的）
• 28个实例
• 30GB总容量
• 90-93%的命中率（用过squid的人可能知道，squid内存加磁盘的命中率大概在70-80%）

如何建立缓存策略？

想缓存所有的东西？那是不可能的，我们只需要缓存已经或者可能导致系统瓶颈的地方，最大程度的提交系统运行效率。通过对MySQL的日志的分析我们可以找到缓存的对象。

缓存的缺点？

• 没有完美的事物，缓存也有缺点：
• 增大开发量，需要针对缓存处理编写特殊的代码。
• 管理难度增加，需要更多人参与系统维护。
• 当然大内存也需要钱。

10、Web访问负载均衡

在数据包级别使用BIG-IP，但BIG-IP并不知道我们内部的处理机制，无法判断由哪台服务器对这些请求进行处理。反向代理并不能很好的起到作用，不是已经够快了，就是达不到我们想要的效果。

所以，LJ又开发了Perlbal。特点：

• 快，小，可管理的http web 服务器/代理
• 可以在内部进行转发
• 使用Perl开发
• 单线程，异步，基于事件，使用epoll , kqueue
• 支持Console管理与http远程管理，支持动态配置加载
• 多种模式：web服务器，反向代理，插件
• 支持插件：GIF/PNG互换？

11、MogileFS

LJ使用开源的MogileFS作为分布式文件存储系统。MogileFS使用非常简单，它的主要设计思想是：

• 文件属于类（类是最小的复制单位）
• 跟踪文件存储位置
• 在不同主机上存储
• 使用MySQL集群统一存储分布信息
• 大容易廉价磁盘

到目前为止就这么多了，更多文档可以在http://www.danga.com/words/找到。Danga.com和LiveJournal.com的同学们拿这个文档参加了两次MySQL Con，两次OS Con，以及众多的其它会议，无私的把他们的经验分享出来，值得我们学习。在web2.0时代快速开发得到大家越来越多的重视，但良好的设计仍是每一个应用的基础，希望web2.0们在成长为Top500网站的路上，不要因为架构阻碍了网站的发展。

本文主要从简化安装==>性能调优==>维护方便的角度，介绍了WEB服务的规划、HTTPD安装/应用模块配置、升级/维护等过程。让Apache和PHP，Resin等应用模块的独立升级，完全互不影响。

1. WEB应用容量规划：根据硬件配置和WEB应用的特点进行WEB服务的规划及一些简单的估算公式；
2. Apache安装过程：apache的通用的简化安装选项，方便以后的应用的模块化配置；
   修改 HARD_SERVER_LIMIT：
   vi /path/to/apache_src/src/include/httpd.h
   #define HARD_SERVER_LIMIT 2560 <===将原来的 HARD_SERVER_LIMIT 256 后面加个“0”
   apache编译：
   ./configure –prefix=/home/apache –enable-shared=max –enable-module=most
3. 可选应用模块/工具的安装：php resin mod_gzip mod_expire及各个模块之间的配合；
   mod_php安装：./configure –with-apxs=/home/apache/bin/apxs –enable-track-vars –with-mysql
   mod_resin安装：./configure –with-apxs=/home/apache/bin/apxs
   mod_gzip安装：修改Makefile中的 apxs路径：然后make make install
   工具：日志轮循工具cronolog安装：http://www.cronolog.org
4. 升级/维护：看看通用和模块化的安装过程如何简化了日常的升级/维护工作；
   按照以上的方法：系统管理员和应用管理员的职责可以清楚的分开，互相独立。
   系统安装：系统管理员的职责就是安装好一台DSO模式的Apache，然后COLON即可，
   应用安装：由应用管理员负责具体应用所需要的模块，比如PHP Resin等，并设置httpd.conf中相关的配置。
   系统升级：系统管理员：升级操作系统/升级Apache
   应用升级：应用管理员：升级应用模块，PHP Resin等。

WEB应用的容量规划

Apache主要是一个内存消耗型的服务应用，我个人总结的经验公式：
apache_max_process_with_good_perfermance < (total_hardware_memory / apache_memory_per_process ) * 2
apache_max_process = apache_max_process_with_good_perfermance * 1.5

为什么会有一个apache_max_process_with_good_perfermance和apache_max_process呢？原因是在低负载下系统可以使用更多的内存用于文件系统的缓存，从而进一步提高单个请求的响应速度。在高负载下，系统的单个请求响应速度会慢不少，而超过 apache_max_process，系统会因为开始使用硬盘做虚拟内存交换空间而导致系统效率急剧下降。此外，同样的服务：2G内存的机器的 apache_max_process一般只设置到1G内存的1.7倍，因为Apache本身会因为进程过多导致性能下降。

例子1：
一个apache + mod_php的服务器：一个apache进程一般需要4M内存
因此在一个1G内存的机器上：apache_max_process_with_good_perfermance < (1g / 4m) * 2 = 500
apache_max_process ＝ 500 * 1.5 = 750
所以规划你的应用让服务尽量跑在500个进程以下以保持比较高的效率，并设置Apache的软上限在800个。

例子2：
一个apache + mod_resin的服务器： 一个apache进程一般需要2M内存
在一个2G内存的机器上：
apache_max_process_with_good_perfermance < (2g / 2m ) * 2 = 2000
apache_max_process ＝ 2000 * 1.5 = 3000

以上估算都是按小文件服务估算的（一个请求一般大小在20k以下）。对于文件下载类型站点，可能还会受其他因素：比如带宽等的影响。

Apache安装过程

服务器个数的硬上限HARD_SERVER_LIMIT的修改：
在Apache的源代码中缺省的最大进程数是256个，需要修改apache_1.3.xx/src/include/httpd.h
#ifndef HARD_SERVER_LIMIT
#ifdef WIN32
#define HARD_SERVER_LIMIT 1024
#elif defined(NETWARE)
#define HARD_SERVER_LIMIT 2048
#else
#define HARD_SERVER_LIMIT 2560 <===将原来的HARD_SERVER_LIMIT 256 后面加个“0”
#endif
#endif

解释：
Apache缺省的最大用户数是256个：这个配置对于服务器内存还是256M左右的时代是一个非常好的缺省设置，但随着内存成本的急剧下降，现在大型站点的服务器内存配置一般比当时要高一个数量级不止。所以256个进程的硬限制对于一台1G内存的机器来说是太浪费了，而且Apache的软上限 max_client是受限于HARD_SERVER_LIMIT的，因此如果WEB服务器内存大于256M，都应该调高Apache的 HARD_SERVER_LIMIT。根据个人的经验：2560已经可以满足大部分小于2G内存的服务器的容量规划了（Apache的软上限的规划请看后面）。

Apache的编译：以下通用的编译选项能满足以后任意模块的安装
./configure –prefix=/another_driver/apache/ –enable-shared=max –enable-module=most
比如：
./configure –prefix=/home/apache/ –enable-shared=max –enable-module=most

解释：
–prefix=/another_driver/apache/：建议将apache服务安装在另外一个驱动设备上的目的在于硬盘往往是一个系统使用寿命最低的设备，因此：将服务数据和系统完全分开，不仅能提高了数据的访问速度，更重要的，大大方便系统升级，应用备份和恢复过程。

–shared-module=max：使用动态加载方式载入子模块会带来5%的性能下降，但和带来的配置方便相比更本不算什么：比如模块升级方便，系统升级风险降低，安装过程标准化等

–enable-module=most：用most可以将一些不常用的module编译进来，比如后面讲到的mod_expire是就不在 apache的缺省常用模块中

如果不想build so, 也可以这样:
./configure \
“–with-layout=Apache” \
“–prefix=/path/to/apache” \
“–disable-module=access” \
“–disable-module=actions” \
“–disable-module=autoindex” \
“–disable-module=env” \
“–disable-module=imap” \
“–disable-module=negotiation” \
“–disable-module=setenvif” \
“–disable-module=status” \
“–disable-module=userdir” \
“–disable-module=cgi” \
“–disable-module=include” \
“–disable-module=auth” \
“–disable-module=asis”

但结果会发现，这样编译对服务性能只能有微小的提高（5%左右），但却失去了以后系统升级和模块升级的灵活性，无论是模块还是Apache本身升级都必须把Apache和PHP的SOURCE加在一起重新编译。

apache的缺省配置文件一般比较大：可以使用去掉注释的方法精简一下：然后再进入具体的培植过程能让你更快的定制出你所需要的。
grep -v “#” httpd.conf.default >httpd.conf

需要修改的通用项目有以下几个：

#服务端口，缺省是8080，建议将整个Apache配置调整好后再将服务端口改到正式服务的端口
Port 8080 => 80

#服务器名：缺省没有
ServerName name.example.com

#最大服务进程数：根据服务容量预测设置
MaxClients 256 => 800

#缺省启动服务后的服务进程数：等服务比较平稳后，按平均负载下的httpd个数设置就可以
StartServers 5 => 200

不要修改：
以前有建议说修改：
MinSpareServers 5 => 100
MaxSpareServers 10 => 200

但从我的经验看来：缺省值已经是非常优化的了，而且让Apache自己调整子共享进程个数还是比较好的。

特别修改：
在solaris或一些比较容易出现内存泄露的应用上：
MaxRequestsPerChild 0 =>3000

应用模块和工具的安装配置：

由于使用模块动态加载的模式，所以可以方便的通过简单的配置调整来把Apache定制成你需要的：最好把不常用模块全部清除（无论处于安全还是效率）。
比如：对于静态页面服务器：就什么其他子模块都不加载，对于PHP应用就加上PHP模块，对于JAVA应用就把Resin模块加载上。而且各种模块的插拔非常简单，这样调试过程中就可以简单的通过注释掉不需要的模块，而不用重新编译。

一般说来，可以不需要的模块包括：
#LoadModule env_module libexec/mod_env.so
#LoadModule negotiation_module libexec/mod_negotiation.so
#LoadModule status_module libexec/mod_status.so
#server side include已经过时了
#LoadModule includes_module libexec/mod_include.so
#不需要将没有缺省index文件的目录下所有文件列出
#LoadModule autoindex_module libexec/mod_autoindex.so
#尽量不使用CGI：一直是Apache安全问题最多的地方
#LoadModule cgi_module libexec/mod_cgi.so
#LoadModule asis_module libexec/mod_asis.so
#LoadModule imap_module libexec/mod_imap.so
#LoadModule action_module libexec/mod_actions.so
#不使用安全认证可以大大提高访问速度
#LoadModule access_module libexec/mod_access.so
#LoadModule auth_module libexec/mod_auth.so
#LoadModule setenvif_module libexec/mod_setenvif.so

最好保留的有：
#用于定制log格式
LoadModule config_log_module libexec/mod_log_config.so
#用于增加文件应用的关联
LoadModule mime_module libexec/mod_mime.so
#用于缺省index文件：index.php等
LoadModule dir_module libexec/mod_dir.so

可用可不用的有：
#比如：需要在~/username/下调试php可以将
LoadModule userdir_module libexec/mod_userdir.so
#比如：需要将以前的URL进行转向或者需要使用CGI script-alias
LoadModule alias_module libexec/mod_alias.so

常用的模块：
最常用的可能就是php和JAVA应用服务器的前端，此外，从性能上讲利用mod_gzip可以减少40%左右的流量，减少机器用于传输的负载，而 mod_expires可以减少10%左右的重复请求，让重复的用户对指定的页面请求结果都CACHE在本地，根本不向服务器发出请求。

建议将所有MODULE的配置都放到相应模块的配置内部：<IfModule some_module.c>some_module config </IfModule>

PHP的安装：
/path/to/php_src/configure –with-apxs=/path/to/apache/bin/apxs –with-other-modules-you-need
需要修改的配置：
AddType application/x-httpd-php .php .php3 .any_file_in_php

resin的安装设置：
/path/to/resin/src/configure –with-apxs=/path/to/apache/bin/apxs

具体的resin设置放在另外一个文件中：比如/home/resin/conf/resin.conf
<IfModule mod_caucho.c>
CauchoConfigFile /path/to/apache/conf/resin.conf
</IfModule>

mod_expires的安装配置：
<IfModule mod_expires.c>
ExpiresActive on
ExpiresByType image/gif “access plus 1 month”
ExpiresByType text/css “now plus 1 month”
ExpiresDefault “now plus 1 day”
</IfModule>

注释：
所有的.gif文件1个月以后过期
所有的文件缺省1天以后过期

mod_gzip的安装

http://www.chedong.com/tech/compress.html

日志的轮循：cronolog的安装和设置

cronolog可以非常整齐的将日志按天轮循存储
缺省编译安装到/usr/local/bin/下，只需要将配置改成：

CustomLog “|/usr/local/sbin/cronolog /home/apache/logs/%w/access_log” combined
日志将按天截断并存放在以星期为目录名的目录下：比如：log/1是周一，log/5是周五, log/0是周日

用gzip压缩每天的日志：
30 4 * * * /usr/bin/gzip -f /home/apache/logs/`date -d yesterday +%w`/access_log

日志的定期删除：
30 5 * * */usr/bin/find /home/apache/logs/ -name access_log.gz -mtime +3 |xargs -r /bin/rm -f

升级维护：

由于使用动态模块加载方式（DSO模式)安装Apache，Apache的HTTPD核心服务和应用模块以及应用模块之间都变的非常灵活，建议将所有独立模块的配置都放在
<IfModule mod_name>
CONFIGURATIONS..
</IfModule>
里，这样配置非常容易通过屏蔽某个模块来进行功能调整：比如：
#AddModule mod_gzip.c
就屏蔽了mod_gzip，而其他模块不首任何影响。

安装和维护过程：

• 系统安装：系统管理员的职责就是安装系统和一个按照DSO模式安装的Apache，然后COLON。
• 应用安装：由应用管理员负责具体应用所需要的模块并设置HTTPD。
• 系统升级：系统管理员：升级系统/升级Apache
• 应用升级：应用管理员：升级应用模块：PHP CAUCHO等
• 系统备份/恢复：如果Apache不在缺省的系统盘上，只需要将Apache目录备份就可以了，遇到系统分区的硬件问题直接使用预先准备好的系统COLON，再直接将Apache所在物理盘恢复就行了。

例子：Apache和PHP模块的独立升级。

如果Apache是按照以下方式安装：
./configure –prefix=/home/apache –enable-shared=max –enable-module=most
PHP是按照以下方式安装：
./configure –with-apxs=/home/apache/bin/apxs –enable-track-vars –with-mysql

以后单独升级Apache的时候，仍然是：
./configure –prefix=/home/apache –enable-shared=max –enable-module=most
make
su
#/home/apache/bin/apachectl stop
#make install

单独升级php时，仍然是：
./configure –with-apxs=/home/apache/bin/apxs –enable-track-vars –with-mysql
make
su
#/home/apache/bin/apachectl stop
#make install
#/home/apache/bin/apachectl start

基于反相代理的WEB加速：
squid和mod_proxy都可以实现反相代理加速。而基于缓存的代理加速比起原有WEB服务，速度会有数量级的提升。
小提示：

Apache安装后，缺省根目录下没有但很有用的2个文件:

• favicon.ico: favicon.ico是一个16×16的站点图标文件，如果浏览器发现有这个文件，在地址栏中会用这个图标替换调浏览器的网页图标。IE6和 MOZILLA等主流浏览器都支持这个功能。
  例如： http://www.chedong.com/favicon.ico
  
• robots.txt: 用于告诉搜索引擎的爬虫程序（spider）网站那些页面可以被索引，那些不可以。
  具体说明请参考：http://www.robotstxt.org/wc/robots.html

prefork

prefork采用预派生子进程方式，用单独的子进程来处理 不同的请求，进程之间彼此独立。在make编译和make install安装后，使用httpd -l来确定当前使用的MPM是prefork.c。查看httpd-mpm.conf配置文件，里面包含如下默认的配置段：

<IfModule prefork.c>
StartServers 5
MinSpareServers 5
MaxSpareServers 10
MaxClients 150
MaxRequestsPerChild 0
</IfModule>
prefork 控制进程在最初建立“StartServers”个子进程后，为了满足MinSpareServers设置的需要创建一个进程，等待一秒钟，继续创建两个，再等待一秒钟，继续创建四个……如此按指数级增加创建的进程数，最多达到每秒32个，直到满足MinSpareServers设置的值为止。这种模式可以不必在请求到来时再产生新的进程，从而减小了系统开销以增加性能。MaxSpareServers设置了最大的空闲进程数，如果空闲进程数大于这个值，Apache会自动kill掉一些多余进程。这个值不要设得过大，但如果设的值比MinSpareServers小，Apache会自动把其调整为 MinSpareServers+1。如果站点负载较大，可考虑同时加大MinSpareServers和MaxSpareServers。 MaxRequestsPerChild设置的是每个子进程可处理的请求数。每个子进程在处理了“MaxRequestsPerChild”个请求后将自动销毁。0意味着无限，即子进程永不销毁。虽然缺省设为0可以使每个子进程处理更多的请求，但如果设成非零值也有两点重要的好处：1、可防止意外的内存泄漏。2、在服务器负载下降的时侯会自动减少子进程数。因此，可根据服务器的负载来调整这个值。MaxClients是这些指令中最为重要的一个，设定的是 Apache可以同时处理的请求，是对Apache性能影响最大的参数。其缺省值150是远远不够的，如果请求总数已达到这个值（可通过ps -ef|grep http|wc -l来确认），那么后面的请求就要排队，直到某个已处理请求完毕。这就是系统资源还剩下很多而HTTP访问却很慢的主要原因。虽然理论上这个值越大，可以处理的请求就越多，但Apache默认的限制不能大于256。ServerLimit指令无须重编译Apache就可以加大MaxClients。

<IfModule prefork.c>

ServerLimit  10000
StartServers 5
MinSpareServers 5
MaxSpareServers 10
MaxClients 10000
MaxRequestsPerChild 0
</IfModule>

Worker
相对于prefork，worker全新的支持多线程和多进程混合模型的MPM。由于使用线程来处理，所以可以处理相对海量的请求，而系统资源的开销要小于基于进程的服务器。但是，worker也使用了多进程，每个进程又生成多个线程，以获得基于进程服务器的稳定性。在configure –with-mpm=worker后，进行make编译、make install安装。在缺省生成的httpd-mpm.conf中有以下默认配置段：
<IfModule worker.c>
StartServers 2
MaxClients 150
MinSpareThreads 25
MaxSpareThreads 75
ThreadsPerChild 25
MaxRequestsPerChild 0
</IfModule>
Worker 由主控制进程生成“StartServers”个子进程，每个子进程中包含固定的ThreadsPerChild线程数，各个线程独立地处理请求。同样，为了不在请求到来时再生成线程，MinSpareThreads和MaxSpareThreads设置了最少和最多的空闲线程数；而MaxClients 设置了同时连入的clients最大总数。如果现有子进程中的线程总数不能满足负载，控制进程将派生新的子进程。MinSpareThreads和 MaxSpareThreads的最大缺省值分别是75和250。这两个参数对Apache的性能影响并不大，可以按照实际情况相应调节。 ThreadsPerChild是worker MPM中与性能相关最密切的指令。ThreadsPerChild的最大缺省值是64，如果负载较大，64也是不够的。这时要显式使用 ThreadLimit指令，它的最大缺省值是20000。Worker模式下所能同时处理的请求总数是由子进程总数乘以ThreadsPerChild 值决定的，应该大于等于MaxClients。如果负载很大，现有的子进程数不能满足时，控制进程会派生新的子进程。默认最大的子进程总数是16，加大时也需要显式声明ServerLimit（最大值是20000）。需要注意的是，如果显式声明了ServerLimit，那么它乘以 ThreadsPerChild的值必须大于等于MaxClients，而且MaxClients必须是ThreadsPerChild的整数倍，否则 Apache将会自动调节到一个相应值。
<IfModule worker.c>
ServerLimit 25
ThreadLimit 200
StartServers 3
MaxClients 2000
MinSpareThreads 50
MaxSpareThreads 200
ThreadsPerChild 100
MaxRequestsPerChild 0
</IfModule>

下面是利用Apache自带的测试工具ab对Server进行测试的情况(设定请求的index页面为6bytes),cpu%为cpu占用率，mem为内存使用量(M为单位)，RequestsPerSecond为每秒处理的请求数。
1、Prefor方式
  (ServerLimit,StartServer,MinSpareServers,MaxSpareServers,MaxClients,MaxRequestPerChild)            

2、Worker方式
(ServerLimt,Threadlimt,Startservers,MaxClients,MinspareThread,MaxspareThread,ThreadperChild,MaxRequestPerChild)
                   

相对来说，prefork方式速度要稍高于worker，然而它需要的cpu和memory资源也稍多于woker。

在很多场合，我们都会听到 memcached 这个名字，但很多同学只是听过，并没有用过或实际了解过，只知道它是一个很不错的东东。这里简单介绍一下，memcached 是高效、快速的分布式内存对象缓存系统，主要用于加速 WEB 动态应用程序。

二、memcached 安装

首先是下载 memcached 了，目前最新版本是 1.1.12，直接从官方网站即可下载到 memcached-1.1.12.tar.gz。除此之外，memcached 用到了 libevent，我下载的是 libevent-1.1a.tar.gz。

接下来是分别将 libevent-1.1a.tar.gz 和 memcached-1.1.12.tar.gz 解开包、编译、安装：

# tar -xzf libevent-1.1a.tar.gz
# cd libevent-1.1a
# ./configure --prefix=/usr
# make
# make install
# cd ..
# tar -xzf memcached-1.1.12.tar.gz
# cd memcached-1.1.12
# ./configure --prefix=/usr
# make
# make install

安装完成之后，memcached 应该在 /usr/bin/memcached。

三、运行 memcached 守护程序

运行 memcached 守护程序很简单，只需一个命令行即可，不需要修改任何配置文件（也没有配置文件给你修改 ）：

/usr/bin/memcached -d -m 128 -l 192.168.1.1 -p 11211 -u httpd

参数解释：

-d 以守护程序（daemon）方式运行 memcached；
-m 设置 memcached 可以使用的内存大小，单位为 M；
-l 设置监听的 IP 地址，如果是本机的话，通常可以不设置此参数；
-p 设置监听的端口，默认为 11211，所以也可以不设置此参数；
-u 指定用户，如果当前为 root 的话，需要使用此参数指定用户。

当然，还有其它参数可以用，man memcached 一下就可以看到了。

四、memcached 的工作原理

首先 memcached 是以守护程序方式运行于一个或多个服务器中，随时接受客户端的连接操作，客户端可以由各种语言编写，目前已知的客户端 API 包括 Perl/PHP/Python/Ruby/Java/C#/C 等等。PHP 等客户端在与 memcached 服务建立连接之后，接下来的事情就是存取对象了，每个被存取的对象都有一个唯一的标识符 key，存取操作均通过这个 key 进行，保存到 memcached 中的对象实际上是放置内存中的，并不是保存在 cache 文件中的，这也是为什么 memcached 能够如此高效快速的原因。注意，这些对象并不是持久的，服务停止之后，里边的数据就会丢失。

三、PHP 如何作为 memcached 客户端

有两种方法可以使 PHP 作为 memcached 客户端，调用 memcached 的服务进行对象存取操作。

第一种，PHP 有一个叫做 memcache 的扩展，Linux 下编译时需要带上 –enable-memcache[=DIR] 选项，Window 下则在 php.ini 中去掉 php_memcache.dll 前边的注释符，使其可用。

除此之外，还有一种方法，可以避开扩展、重新编译所带来的麻烦，那就是直接使用 php-memcached-client。

本文选用第二种方式，虽然效率会比扩展库稍差一些，但问题不大。

四、PHP memcached 应用示例

首先 下载 memcached-client.php，在下载了 memcached-client.php 之后，就可以通过这个文件中的类“memcached”对 memcached 服务进行操作了。其实代码调用非常简单，主要会用到的方法有 add()、get()、replace() 和 delete()，方法说明如下：

add ($key, $val, $exp = 0)
往 memcached 中写入对象，$key 是对象的唯一标识符，$val 是写入的对象数据，$exp 为过期时间，单位为秒，默认为不限时间；

get ($key)
从 memcached 中获取对象数据，通过对象的唯一标识符 $key 获取；

replace ($key, $value, $exp=0)
使用 $value 替换 memcached 中标识符为 $key 的对象内容，参数与 add() 方法一样，只有 $key 对象存在的情况下才会起作用；

delete ($key, $time = 0)
删除 memcached 中标识符为 $key 的对象，$time 为可选参数，表示删除之前需要等待多长时间。

下面是一段简单的测试代码，代码中对标识符为 ‘mykey’ 的对象数据进行存取操作：

<pre>
<?php
//  包含 memcached 类文件
require_once('memcached-client.php');
//  选项设置
$options = array(
    'servers' => array('192.168.1.1:11211'), //memcached 服务的地址、端口，可用多个数组元素表示多个 memcached 服务
    'debug' => true,  //是否打开 debug
    'compress_threshold' => 10240,  //超过多少字节的数据时进行压缩
    'persistant' => false  //是否使用持久连接
    );
//  创建 memcached 对象实例
$mc = new memcached($options);
//  设置此脚本使用的唯一标识符
$key = 'mykey';
//  往 memcached 中写入对象
$mc->add($key, 'some random strings');
$val = $mc->get($key);
echo "n".str_pad('$mc->add() ', 60, '_')."n";
var_dump($val);
//  替换已写入的对象数据值
$mc->replace($key, array('some'=>'haha', 'array'=>'xxx'));
$val = $mc->get($key);
echo "n".str_pad('$mc->replace() ', 60, '_')."n";
var_dump($val);
//  删除 memcached 中的对象
$mc->delete($key);
$val = $mc->get($key);
echo "n".str_pad('$mc->delete() ', 60, '_')."n";
var_dump($val);
?>
</pre> 

是不是很简单，在实际应用中，通常会把数据库查询的结果集保存到 memcached 中，下次访问时直接从 memcached 中获取，而不再做数据库查询操作，这样可以在很大程度上减轻数据库的负担。通常会将 SQL 语句 md5() 之后的值作为唯一标识符 key。下边是一个利用 memcached 来缓存数据库查询结果集的示例（此代码片段紧接上边的示例代码）：

<?php
$sql = 'SELECT * FROM users';
$key = md5($sql);   //memcached 对象标识符
if ( !($datas = $mc->get($key)) ) {
    //  在 memcached 中未获取到缓存数据，则使用数据库查询获取记录集。
    echo "n".str_pad('Read datas from MySQL.', 60, '_')."n";
    $conn = mysql_connect('localhost', 'test', 'test');
    mysql_select_db('test');
    $result = mysql_query($sql);
    while ($row = mysql_fetch_object($result))
        $datas[] = $row;
    //  将数据库中获取到的结果集数据保存到 memcached 中，以供下次访问时使用。
    $mc->add($key, $datas);
} else {
    echo "n".str_pad('Read datas from memcached.', 60, '_')."n";
}
var_dump($datas);
?>
 

可以看出，使用 memcached 之后，可以减少数据库连接、查询操作，数据库负载下来了，脚本的运行速度也提高了。

打开一个网站，然后直接把这段js贴在url后面，就能出现奇迹，呵呵！

3.memcache使用优化
       在优化memcache的工作之前,需要了解memcache体系的工作流程.一个分布式的memcache的运作是需要三个部分的,多台提供 memcache服务的servers(简称S),一个进行分布式映射的中间层lib(其实这个也可以当作客户端的一部分,简称L),和进行 memcache请求的客户端(简称C).
       在memcache工作时,有以下四个步骤:
       1.  C通过带有特性化的Key值的命令串,向L请求memcache服务,L将命令串进行分解,并通过对key的某种Hash算法决定S的地址
       2.  L将分解的(Comm Key-Value)或者(Comm Key)向相关的S请求memcache服务.
       3.  相关的S根据memcache协议向L返回服务结果.
       4.  L将结果进行聚集包装后返回给C一个人性化的响应.
       这个流程可以用图3.1进行描述.

图3.1 memcache工作步骤
       在每个S端,请求处理的Key-Value对当作一个对象(不过这个对象的结构是单一的),再进行另一步hash之后,存储在内存里.存储算法在第二部分有详细的描述.这种通过双层hash来分开处理分布式和缓存两个功能的方法值得学习.
       从上面的分析可以看出,分布式的memcache服务是需要很大的网络开销的.对于一般的应用而言,是否都要进行memcache的优化,甚至是否需要用到memcache,都需要进行权衡分析.如果只是本地小规模的应用,在数据库可承受的范围内,是宁愿采用数据库+文件缓存的方式.1.1版本的 memcache走TCP模式在本地应用的处理速度甚至比不上Mysql数据的Unix域套接口的处理速度的一半,当然会更加比不上在程序内部直接操作内存了.虽然1.2版本的memcache已经提供了-s参数指定Unix域套口和-u指定udp模式.而且如果不需要用到分布式的话,不推荐使用 memcache,除非你的内存足够大到浪费的程度.
       因此,在进行优化之前,需要看看是否真的需要优化memcache,是否真正需要用到memcache.
       优化可以从以下几个方面进行：
       1.  命中率.
       对于缓存服务而言,命中率是至关重要的.命中率的提升可以通过多种方案实现.其一,提高服务获取的内存总量.这无疑是增加命中的最直接的办法,将缓存数据完全放入数据池中.只要连接不失效,就一定命中.其二,提高空间利用率,这实际上也是另一种方式的增加内存总量.具体实现在下一个方面给出.其三,对于一些很特别的memcache应用,可以采用多个memcache服务进行侦听,分开处理,针对服务提供的频繁度划分服务内存,相当于在应用一级别上再来一次LRU.其四,对于整体命中率,可以采取有效的冗余策略,减少分布式服务时某个server发生服务抖动的情况.如,14台机器实现分布式 memcache,划分两组服务,其中一组13台做一个分布式的memcache,一组1台做整个的memcache备份.对于update操作,需要进行两边,get操作只需要一遍,一旦访问失效,则访问备份服务器.这样,对于备份服务器需要内存比较大,而且只适应于读操作大于写操作的应用中.这可以认为是RAID3,当然,也可以采用RAID1完全镜像.
       2.  空间利用率.
       对于使用memcache做定长数据缓存服务而言,是可以在空间利用率上进行优化.甚至最简单的办法可以不用更改memcache的源码遍可以完成由- f和-n参数的配合可以做到定长优化,不过极可能需要浪费掉预分配的199M内存空间.当然前提是memcache的版本是1.2,同时如果使用的是 1.2.0和1.2.1的话,需要更改掉一个BUG,那就是getopt时将opt串中最后一个”s”改成”n”,希望memcache能在以后的版本发现这个BUG.例如,如果key是一个定长id(如一个8位的流水号00000001),value是一个定长的串(如16位的任意字符串),对应于一个 chunk_size可以这么计算:chunk_size = sizeof(item) + nkey + *nsuffix + nbytes = 32 + 9 + (flag的数位长度 )2+ (16)的数位长度) 2+(两换行的长度)4 + 17 = 40 + 10 + 16 = 66,那么可以通过 -f 1.000001 -n  `expr 66 – 32`,即 -f 1.000001 -n 34 来启动memcache.这种情况下,会浪费掉memcache预先分配的200M空间中的199M.从第2个预分配等级到第200个预分配等级将不会用到.然而,存在解决办法,那就是在编译memcache是加入编译参数-DDONT_PREALLOC_SLABS,或者在源代码中加入#define DONT_PREALLOC_SLABS即可,只是会去除memcache的预分配内存机制.
       如果需要memcache的预分配内存机制,那么需要对其源代码进行修改.修改如下:  

引用

   1. 在slabs.c中,将函数slabs_clsid改成:
     unsigned int slabs_clsid(size_t size)
     {   unsigned int res = POWER_SMALLEST;
       if(size==0)
                 return 0;
       res = (size)%power_largest;
       return res;
     }
   2. 在item.c中,将函数 item_make_header改为:
     int item_make_header(char *key, uint8_t nkey, int flags, int nbytes,
                    char *suffix, int *nsuffix)
     {
           *nsuffix = sprintf(suffix, ” %u %u\r\n”, flags, nbytes – 2);
           return sizeof(item)+ nkey + *nsuffix + nbytes + hash(key,nkey,0);
     }
   3. 在item.c中,将函数 item_free改为:
     void item_free(item *it)
     {  unsigned int ntotal = it->slabs_clsid;
           assert((it->it_flags & ITEM_LINKED) == 0);
           assert(it != heads[it->slabs_clsid]);
           assert(it != tails[it->slabs_clsid]);
           assert(it->refcount == 0);

           it->slabs_clsid = 0;
           it->it_flags |= ITEM_SLABBED;
           slabs_free(it, ntotal);
     }
       做一个轮流存储的机制使用预分配的内存,这样的好处是其他地方不需要做任何修改就可以了,当然你可以在源代码中加入上面的代码,并将它们放在一个自定义的宏后面.
       3.  加速比.
       加速比,也即事件的处理效率.是否可以修改libevent的事件处理效率,需要研究.如果内存空间很大,可以将freeconn的数值调大,增加预分配的conn内存大小.
       是否可以将memcache做成多线程处理,但在处理多线程数据同步是个问题.
        如果有时间,愿意来试试这个策略.
       4.  安全性能.
       memcache还存在一个比较显著的问题,那就是其安全性能.只要了解memcache监听的端口,对于能够使用分布式memcache进行数据通信的网络环境的机器,都可以通过memcache协议于memcache服务器进行通信,获取或种植数据.不能保证种植进内存里的数据不会被别有心意的人再利用.也不能保证服务器的内存不被漫天遍地的垃圾数据所堆积,造成命中极低.
       memcache的设计理念在一个轻字,如果对每次Client的通讯需要校验身份,那么恐怕memcache也就达不到其想要的效果了.存在解决办法缓解这个问题,一般而言,需要使用memcache服务的机器,可以在Server维持一张红色列表.这张表上的机器便可以获取服务.很显然, memcache并非任意Client都能访问,只有信任的机器访问,那么为什么不将这些信任的机器放在一个/etc/mem_passwd下呢.
       还有,memcached走udp时,很大几率接受到upd时,都会使服务死掉,特别是set,add,replace时,这个问题需要去考究一下.不过没有时间了.

4.memcache测试分析
       服务器端memcache在命令行运行的参数:

引用

# memcached –d –m 512 –l *.*.*.* -u ** -f 1.00001 –n 16 –c 10000 -vv

       1.  读写memcache指令测试
       在利用了memcache官方推荐的c客户端libmemcache和自己编写的一个简单客户端测试之后,在set/get/add/del指令的运行速度如表4.1和图4.1所示:

表4.1 memcache的指令运行速度
图4.1 memcache的指令运行速度
       2.  并发连接
       由于在memcache服务器端,一个结点运行的是单进程单线程的daemon(或非daemon)服务,同时对于采用了libevent处理网络IO 而言,其并发连接的数目是和libevent采用的机制相关连的.很显然,accept函数在接收到connection后将Client的socket 放进event库中,等待处理.而libevent库在LINUX中使用的是epoll,监听EPOLLIT水平触发.因此从理论上讲,memcache 的并发连接可以达到infinite,前提是event池和内存空间足够大.而没有和linux的线程处理有关系.事实上,在后面的测试中便可发现,在单结点连接压力测试时,瞬时并发连接可以达到5000多个.只是等待触发时间上的长短和有效无效的区别.
       在表4.2中可以清晰的看到并发连接的一些数据.
       3.  服务端系统负载
       通过自己编写的服务器端,对单结点的memcache进行了连接压力测试.其中测试用例的编写是这样的:启用七个客户端,每个客户端串行运行1000个进程,每个进程开3000线程,每个线程执行10次memcache的读操作或者写操作(操作相同).客户端并发连接.
       1.  客户端(7)的环境:Intel(R) Xeon(R) CPU 5120 @ 1.86GHz,4G memory.
       2.  服务器端(1)的环境:Intel(R) Xeon(R) CPU 5120 @ 1.86GHz,4G memory.
       3.  网络环境:100M网卡,Cisco交换机.
       4.  数据记录:见表4.2和图4.2.

表4.2 memcache连接和系统负载
图4.2 memcache连接和系统负载
       很显然,memcache的运行在系统cpu的消耗上占十分少的比重,即便是很恐怖的并发连接也不会给系统带来多大的负载,因为其磁盘IO free(所有操作都在内存中)和相应的内存分配机制决定其占用cpu的极少,而相反,在网络IO上却花费很大的时间.
       4.  空间分配,命中率
       由于本地测试式的get数据非常固定,因此命中率基本为100%.在10.68.1.31上运行了一个有前端应用的memcachce服务器,运行时间已经有364个多小时了.
       因此通过10.68.1.31上的数据说明(版本为1.1.13).通过memcache的统计协议可以清楚的看到其命中率高达95.9%,如表4.3所示:

表4.3 memcache空间分配和命中

5.memcache客户端编写
       1.  memcache协议
       在memcache协议中规定了Client和Server的通信规则.
       在源码分析中,主要分析了update/get/del/incr/decr几类的处理过程.其具体的规则可以在官方文档中有说明(),这里做简单的解释.

引用

1．  Update(set/add/replace):
Client请求规则：
\r\n
\r\n
Server响应规则：
STORED\r\n 或者 NOT_STORED\r\n

其中，是set,add,replace三种中的一种;
是client请求存储的键值;
是任意16bit长的unsigned int值,在get操作时,也将伴随data一起返回,可以用来存储某些认证信息或者描述信息;
是key－value对象的消亡时间,如果为0,则代表永不消亡;
是数据的长度,千万小心,这个很重要,在memcache源代码里,直接读取这个数值来当作数据的长度,而不是用strlen计算的.这个显而易见,因为数据中有可能存在/r/n符号,也就是协议中规定的分隔符.如果出现,则严格按长度取数据;
也就是value值,可以包含\r\n值.

STORED代表update操作成功，NOT_STORED代表update操作失败.

2．  Get(get/bget)
Client请求规则：
*\r\n
Server响应规则：
VALUE \r\n
\r\n
END\r\n

Get/bget操作可以一次操作多个key值,server的响应格式中的关键字可以参看上面的解释,END代表数据显示结束.如果没有数据,则只有一个END\r\n.

3．  Delete(delete)
Client请求规则：
delete \r\n
Server响应规则：
DELETED\r\n 或者 NOT_DELETED\r\n

其中，是真正删除从server端删除的时间(sec),在时间未到前,server只将其放入一个delete队列里,其他诸如add/replace/get操作不能成功.

4．  Incr/decr(incr/decr)
Client请求规则：
\r\n
Server响应规则：
   NOT_FOUND\r\n 或者 \r\n

   其中,client请求的是将要在对应的value上增减的值;
   Server的是增减后的新值.

5．  其他(如stats/quit等)
可以去看协议原文,使用不是太多.
       2.  针对协议的一个简单实现
       在这个例子中简单实现了一个能进行update/get/delete操作测试用例,只是简单socket的应用而已.如果可以,模仿这个写一个简单的客户端应该难度不大.

引用

/****************************************\
*            mem_benchmark_conn2.c
*
*  Mon Mar 7 10:52:30 2007
*  Copyright  2007  Spark Zheng
*  Mail
*  v0.1 Mar 5 2007 file:mem_benchmark_conn.c
\****************************************/

#include < stdio.h>
#include < stdlib.h>
#include < string.h>
#include < ctype.h>

#include < unistd.h>
#include < pthread.h>
#include < time.h>
#include < sys/types.h>
#include < sys/time.h>
#include < sys/resource.h>
//#include < sys/socket.h>
//#include < netdb.h>
//#include < arpa/inet.h>

#ifndef MEM_SERVER
#define MEM_SERVER “10.210.71.25″
#endif

#ifndef MEM_PORT
#define MEM_PORT 11211
#endif

void p_usage(void);
void *conn_mem(void);
int NonbSocket(const char *server, int port);
int mem_set(int sock,const char *key,const char *value);
int mem_add(int sock,const char *key,const char *value);
int mem_get(int sock,const char *key,char *value);
int mem_del(int sock,const char *key);

int main(int argc,char **argv)
{
       int conn=0;
       int i=0;
       pthread_t ptid[10000];
       struct rlimit rlim;
       struct timeval tv1,tv2;

       if(argc < 2)
       {
               p_usage();
               exit(255);
       }

       conn = atoi(argv[1]);

       if(getrlimit(RLIMIT_NOFILE,&rlim) != 0)
       {
               fprintf(stderr,”getrlimit error in line %d\n”,__LINE__);
               exit(254);
       }

       if((conn > rlim.rlim_cur) && (2*conn > 1024))
       {
               rlim.rlim_cur = 2*conn;
       }
       if(rlim.rlim_cur > rlim.rlim_max)
       {
               rlim.rlim_max = rlim.rlim_cur;
       }

       if(setrlimit(RLIMIT_NOFILE,&rlim) != 0)
       {
               fprintf(stderr,”setrlimit error in line %d\n”,__LINE__);
               exit(254);
       }

       gettimeofday(&tv1,NULL);

       while(i++ < conn)
       {
               if(pthread_create(&ptid[i],NULL,(void *)conn_mem,NULL) != 0)
               {
                       perror(“pthread_create error\n”);
                       exit(253);
               }
       }

       i=0;

       while(i++ < conn)
       {
               if(pthread_join(ptid[i],NULL) != 0)
               {
                       perror(“pthread_join error\n”);
                       exit(253);
               }
       }

       gettimeofday(&tv2,NULL);

       printf(“time is %f,conn is %f persecond\n”,((tv2.tv_sec-tv1.tv_sec)+(tv2.tv_usec-tv1.tv_usec)/1000000.0),conn/((tv2.tv_sec-tv1.tv_sec)+(tv2.tv_usec-tv1.tv_usec)/1000000.0));

       return 0;
}

void p_usage(void)
{
       printf(“Usage:./mem_benchmark_conn < conn_num >\n”);
       printf(“Notice: the conn_num must <= 10000\n”);
       return;
}

void *conn_mem(void)
{
       int sock;
       char *key = “test_a”;
       char *value = “this is a”;

       if((sock=NonbSocket(MEM_SERVER,MEM_PORT)) < 0)
       {
               fprintf(stderr,”socket error in line %d\n”,__LINE__);
               return NULL;
       }

int i=0;
while(i++ < 10)
{
///*
       mem_set(sock,key,value);
//*/
/*
       char *key2=”test_b”;
       char *value2=”this is b”;
       mem_add(sock,key2,value2);
*/
/*
       char buf[101];
       mem_get(sock,key,buf);
       printf(“get value for %s is %s\n”,key,buf);
*/
/*
       char *key3=”test_c”;
       mem_del(sock,key);
*/
}
       close(sock);

       return NULL;
}

int mem_set(int sock,const char *key,const char *value)
{
       char set[101];
       char recv_buf[101];

       sprintf(set,”set %s 0 0 %d\r\n%s\r\n”,key,strlen(value),value);

       if(write(sock,set,strlen(set)) < 0)
       {
               fprintf(stderr,”write error in line %d\n”,__LINE__);
               return -1;
       }

       if(read(sock,recv_buf,100) < 0)
       {
               fprintf(stderr,”read error in line %d\n”,__LINE__);
               return -2;
       }

       printf(“in set %s\n”,recv_buf);

       return 0;
}

int mem_add(int sock,const char *key,const char *value)
{
       char add[101];
       char recv_buf[101];

       sprintf(add,”add %s 0 0 %d\r\n%s\r\n”,key,strlen(value),value);

       if(write(sock,add,strlen(add)) < 0)
       {
               fprintf(stderr,”write error in line %d\n”,__LINE__);
               return -1;
       }

       if(read(sock,recv_buf,100) < 0)
       {
               fprintf(stderr,”read error in line %d\n”,__LINE__);
               return -2;
       }

       printf(“in add %s\n”,recv_buf);

       return 0;
}

int mem_get(int sock,const char *key,char *value)
{
       char get[101];
       char recv_buf[101];

       sprintf(get,”get %s\r\n”,key);

       if(write(sock,get,strlen(get)) < 0)
       {
               fprintf(stderr,”write error in line %d\n”,__LINE__);
               return -1;
       }

       if(read(sock,recv_buf,100) < 0)
       {
               fprintf(stderr,”read error in line %d\n”,__LINE__);
               return -2;
       }

       strncpy(value,recv_buf,strlen(recv_buf));

       printf(“in get %s\n”,recv_buf);

       return 0;
}

int mem_del(int sock,const char *key)
{
       char del[101];
       char recv_buf[101];

       sprintf(del,”delete %s 0\r\n”,key);

       if(write(sock,del,strlen(del)) < 0)
       {
               fprintf(stderr,”write error in line %d\n”,__LINE__);
               return -1;
       }

       if(read(sock,recv_buf,100) < 0)
       {
               fprintf(stderr,”read error in line %d\n”,__LINE__);
               return -2;
       }

       printf(“in del %s\n”,recv_buf);

       return 0;
}
       3.  分布式的实现
       分布式的实现可以这么完成,构建一个struct用于存放server信息.对于每个请求的key值,用很简单的hash算法(如 libmemcache用的是crc32)映射到server数组中的某个数组,然后对其进行通信.获取处理结果之后,将结果美化返回client.

6.libevent简介
       1.  libevent
       libevent是一个事件触发的网络库,适用于windows,linux,bsd等多种平台,内部使用iopc/epoll/kqueue等系统调用管理事件机制,而且根据libevent官方网站上公布的数据统计,似乎也有着非凡的性能.
       从代码中看,libevent支持用户使用三种类型的事件,分别是网络IO,定时器,信号三种,在定时器的实现上使用了红黑树(RB tree)的数据结构,以达到高效查找,排序,删除定时器的目的,网络IO上,libevent的epoll居然用的EPOLLLT水平触发的方式,不容易出错,但是在效率上可能比EPOLLET要低一些.跟网络无关的,libevent也有一些缓冲区管理的函数,libevent没有提供缓存的函数.而且libevent的接口形式非常值得参考.
       2.  epoll
在linux中,libevent用的是epoll.如果有兴趣的话,可以查看man epoll页面.或者看前面blog上引用的libevent的资源.

1.安装Hammerora之前，你应该下载如下的软件包：

• Oracle 9i/10g Windows
• TCL 8.4.11
• TK 8.4.11 
• Threads 2.6.2
• Oratcl 4.3
• optional:
  Oracle intant client

2.Oracle安装就不多说了，除了慢也没什么其他要说的。

3.关于Instant Client的一些说明

可以下载到一个安装文件，里面包括一些动态连接库和类包。因为Hammerora可以再客户端机器上运行（也就是说安装Hammerora的机器上不需要有Oracle数据库，可以远程连接并测试服务器上的数据库），但如果从源代码编译安装Oratcl的时候，需要一些Oracle的库，但客户机上没有，所以如果以客户机的方式运行Hammerora，就要下载一个Instant Client。并且要在客户机上新增环境变量ORACLE_HOME，设置为Instant Client的安装路径。

Instant Client可以从www.oracle.com/technology/software/tech/oci/instantclient/ 下载。

4.TCL/TK的安装要多说一句，sourceforge上比较新的版本都没有提供预先编译和制作好的binary版本，只有source code。但.4a2是有binary版本的，但不要使用这个版本。因为预先变异的时候Thread选项没有打开，这个版本不是线程安全的。
编译过程很简单，因为tcl/tk都提供跨平台的编译支持。在windows下可以使用vc 6.0进行编译（推荐）。当然，如果你安装了VS .Net或者只使用Visual C++ Toolkit 2003也可以进行编译，稍微麻烦一点，具体参考http://wiki.tcl.tk/11431。我使用vc 6.0进行编译。

典型的批处理编译命令如下（以tcl为例，tk和thread类似）：

Tk和Thread安装过程基本一样，不过需要指定tcl源代码的路径，因为这些源代码包会引用一些tcl的c头文件。

TCL_HOME%/lib下新建一个目录叫做Thread,在里面添加一个包索引文件命名为pkgIndex.tcl，内容为：package ifneeded Thread 2.6 [list load [file join $dir thread26.dll]]

然后把编译好Thread2.6.2拷贝到Thread目录下。

6.安装Oratcl也很简单，Oratcl的安装包下有install.tcl，使用wish84或者tclsh执行即可。

7.测试是否安装成功，可以打开wish84或tclsh，运行以下命令：
package require Thread
package require Oratcl
如果成功，则表明安装成功。

8.Hammerora安装，可以从sourceforge上下载到Hammerora的windows安装文件。双击安装就好了。不过要注意的是，Hammerora会自带一个tcl的解释器，但这个解释器不是线程安全和也没有oratcl扩展库。所以把Hammerora.bat改一下：把wish84的路径改成你刚编译安装tcl的路径就好了。

1.这篇文字在操作步骤之前翻译自：http://hammerora.sourceforge.net/tpc-c.htm。

2.适合于英文不好和时间紧迫之人。

3.有什么错误欢迎指出。

TPC-C基准是目前最知名的数据库基准，关于它的详细信息可以在tpc.org的主页上找到。目前已经发布了5.1版，在TPC的主页上有一份TPC的详细说明。这份说明和其中的示例过程是hammerora tpc-c基准测试的实现基础。

所有的SQL语句都是原封不动的从说明中拷贝过来的，没有进行任何的优化。唯一的改变就是将标准中的数据库操作与Oracle进行了集成，并改正了说明中的个别SQL语法错误。但必须注意的是，这个实现并不是TPC-C基准的一个完全的实现。这个实现在不使用复杂的事务管理软件的前提下，尽可能的实现了TPC-C基准。

Hammerora包含了所有用于创建TPC-C关系模式和装载TPC-C基准数据所需要的Oracle存储过程和TCL脚本。

如果想要创建TPC-C的关系模式，首先选择TPC-C关系模式选项，并根据将要创建关系模式的数据库的基本信息填写表格内容。填写之后，点击”Create TPC-C”按钮并确认提示对话框。Hammerora会创建必要的用户，表和索引还有存储过程。

在运行TPC-C测试之前，确认DBMS_RANDOM包已经被安装了，确认方法是以sys用户运行$ORACLE_HOME/rdbms/admin/catoctk脚本。然后选择TPC-C驱动脚本菜单项，之后hammerora就会自动创建一个TPC-C的驱动脚本。驱动脚本中会根据TPC-C scheme中所填入的值来生成连接字符串。默认状态下，驱动脚本的实现中考虑了键盘敲击时间和思考时间。可以设置KEYANDTHINK变量值为 false关闭对这些时间的计算。

最后创建一定数目的虚拟用户（TPC-C的说明中指出每个实例有10个用户，并且要计算思考时间），然后就可以运行Hammerora来对你的Oracle数据库进行TPC-C的方针测试了。

总之，使用Hammerora进行tpc-c测试的步骤如下（假设system密码是pwd,service id是pku）：

1. 填充TPC-C Scheme：service id:pku;system password:pwd;tpc-c user:tpcc;tpcc password:tpcc;default table space:<whaterver exists>
2. 填充Transaction Counters：connect string:system/pwd@pku
3. 创建TPC-C scheme
4. 创建虚拟用户数，10个/warehouse，其他选项请看文档。
5. 产生驱动脚本
6. run Hammerora Loadtest

ps:如果想要看到实时的tpm统计，那么请点击transaction counter按钮。

2.3 安全性测试
目前网络安全问题日益重要，特别对于有交互信息的网站及进行电子商务活动的网站尤其重要。目前我们的测试没有涵盖网站的安全性的测试，我们拟定采用工具来测定，工具如下
SAINT——- Security Administrator’s Integrated Network Tool
此工具能够测出网站系统的相应的安全问题，并且能够给出安全漏洞的解决方案，不过是一些较为常见的漏洞解决方案。
2.4 稳定性测试
网站的稳定性测试是指网站的运行中整个系统是否运行正常，目前没有更好的测试方案，主要采用将测试服务器长时间运转进行测试。
2.5 浏览器兼容性测试
通过白盒测试或者黑盒测试导出的测试用例，采用相应的工具进行测试，可以采用OpenSTA进行测试，此测试工具可以采用不同的浏览器进行测试。
2.6 可用性/易用性测试
可用性/易用性方面目前我们只能采用手工测试的方法进行评判，而且缺乏一个很好的评判基准进行，此一方面需要大家共同讨论。
2.7 链接测试
超级链接对于网站用户而言意味着能不能流畅的使用整个网站提供的服务，因而链接将作为一个独立的项目进行测试。目前我们已经有了一个测试工具
Xenu——主要测试链接的正确性的工具
可惜的是对于动态生成的页面的测试会出现一些错误。
2.8 代码合法性测试
代码合法性测试主要包括2个部分：程序代码合法性检查与显示代码合法性检查
¨ 程序代码合法性检查
程序代码合法性检查主要标准为《intergrp小组编程规范》，目前采用由SCM管理员进行规范的检查，未来期望能够有相应的工具进行测试。
¨ 显示代码合法性检查
显示代码的合法性检查，主要分为Html、JavaScript、Css代码检查，目前采用
HTML代码检查——采用CSE HTML Validator进行测试
JavaScript、Css也可以在网上下载相应的测试工具。
3 测试工具
OpenSTA
主要做性能测试的负荷及压力测试，使用比较方便，可以编写测试脚本，也可以先行自动生成测试脚本，而后对于应用测试脚本进行测试。
SAINT
网站安全性测试，能够对于指定网站进行安全性测试，并可以提供安全问题的解决方案。
CSE HTML Validator
一个有用的对于HTML代码进行合法性检查的工具
Ab(Apache Bench)
Apache自带的对于性能测试方面的工具，功能不是很多，但是非常实用。
Crash-me
Mysql自带的测试数据库性能的工具，能够测试多种数据库的性能。

上述工具除Ab及Crash-me外均可在以下目录中找得到
\smbserver\apps\linuxapp\intergrp
ab及Crash-me请至相应的网站上察看相应的资料}

4 后记
此文只是对于网站的测试方面做了一个简单的介绍，提供的工具比较少，但是可以保证能够使用（当然都是可以从网上免费得到的），另外还有很多测试工具是需要Money的，大家有兴趣可以试用，对于上述提到的测试工具我也只是做了一个初步的调研，详细的功能说明请察看相关的说明文档。
对于网站的测试中比较重要的还有一个部分就是对于数据库的测试，由于对于数据库性能测试较好的工具需要一些Money因而我们采用Mysql的 Crash-me,但是同时也存在一个问题就是对于不同的数据库的测试采用第三方的工具较好。因而大家可以对于其他数据库性能测试的工具进行研究。

5 参考资料
(1)《软件工程-实践者的研究方法》—–Roger S.Pressman
(2) http://www.softwareqatest.com
(3) http://www.soft.com/
(4) http://www.qaforums.com
(5) http://www.opensta.org

大部分用户往往会死等一个网页出来，而很少会同时做其他事情。没有速度，如何向用户展示流程，如何带给用户进一步的体验呢？

Yahoo! Exceptional Performance团队在Developer Network上总结：80-90%的客户端响应时间都用于下载所有的页面元素：图片、样式表、脚本文件、Flash等等。

因此，加快页面响应速度，提高页面性能是提高用户体验重要的第一步。

Yahoo!最近提供了一个页面性能分析工具YSlow，以Firefox Add-on的形式集成到Firebug中。

装上这个工具后，它会分析页面加载的所有内容，根据加速站点的13条规则给站点页面评分并给出建议。

并且它会列出所分析页面上所有元素的类型：URL、过期时间、gzip状态、load时间、文件大小、ETag、包括HTTP响应报头，以及页面Empty Cache和Full Cache时的数据。

Yahoo!页面加速的13条规则如下：（http://developer.yahoo.com/performance/rules.html#num_http ）

1. 减少 HTTP 请求

2. 使用 CDN

3. 为网页元素添加 Expires Header

4. 支持 Gzip

5. 把 CSS 放在网页顶部

6. 把活动的脚本文件移到底部

7. CSS中避免使用Expression语句

8. 使用外部 JavaScript 和 CSS 文件

9. 减少 DNS 查表时间

10. 最小化 JavaScript

11. 避免网页跳转

12. 删除重复的脚本

13 .配置Etag

XXX站点首页的测试:

Google
用哪些软件做 Web Server?
除了有两个节点操作系统看出来是 Linux 外，其他的都是未知的. Web 服务器用的都是 GWS ? 我估计是 Google Web Server 的缩写．

Yahoo!
操作系统都是 FreeBSD. 其他的都不可知.Yahoo! 的网络安全据说是一级棒!

微软
操作系统全是 Windows 2003(如果使用 Linux 会被笑死) , 看来 Windows 2000 已经退出微软自己的舞台．Web 服务器用的是Microsoft-IIS/6.0．

eBay
操作系统用:Windows Server 2003 /2000, Web服务器用 Microsoft-IIS/6.0 (5.0). 对这个检测有些怀疑．eBay 大规模使用 Windows ?

GNU.org
操作系统全是 Debian Linux(没错,Debian 是 GNU 正宗传人)． Web 服务器: Apache/1.3.31 (Debian GNU/Linux) mod_python/2.7.10 Python/2.3.4 , 也有的配置是：Apache/1.3.26 (Unix) Debian GNU/Linux mod_python/2.7.8 Python/2.1.3．GNU.org 对 Python 用的比较多的．

看看国内的一些公司．

阿里巴巴
操作系统是 Linux . Web 服务器: Apache/1.3.29 (Unix) mod_alibaba/1.0 Resin/2.1.13 .
(+mod_gzip/1.3.26.1a). mod_alibaba 模块估计是专门定制的．

Sina
操作系统是 FreeBSD. Web 服务器都是 Apache/2.0.54 .

百度
操作系统是 Linux , Web 服务器: Apache/1.3.27. 整齐划一．

搜狐
操作系统居然是 SCO UNIX ,Web 服务器信息: Apache/1.3.33 (Unix) mod_gzip/1.3.19.1a
看来业界传闻”Sohu 的技术力量最差”并不夸张．

网易
操作系统:Linux. Web 服务器信息: Apache/2.0.5x

这些数据是在Netcraft得到的．

分析一下上述数据，可以得到的基本信息如下:

1. Linux vs FreeBSD 半斤八两．很多公司用 Linux , FreeBSD 也不乏拥趸．但开源操作系统做 Web 应用是首选已经是一个既定事实．
2. 关于 Apache ,虽然 Apache 目前还是推荐使用 1.3 版本. 但是很多公司还是使用了 2.0 版．而 Apache.org 自己也全在使用 Apache 2.0 .甚至是 2.2 ．
3. Mod_gzip 被一些公司有选择的使用．
4. 技术实力强的公司定制自己专用的模块.
这些判断的前提是 Netcraft 的探测是正确的并且具备代表性.