最近实现了一个http的接口 ~ http的方式，访问结果为json

nginx做负载，web分离，url转发 ~

tornado做数据操作和异步调用lua的接口 ~

memcached做session的共享 (为啥不用redis做session，一方面是为了不和redis有kv冲突，服务器的中断冗余，更主要的方面是用redis存储session我没有做出来，郁闷呀。。。。)

redis做kv数据库和队列系统

后端的nginx lua是mysql的http方式的json展现接口

nginx 的配置大家都懂的,就是利用upstream负载。

worker_processes 4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
events {
    worker_connections 30000;
    useepoll;
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
http {
    charset utf-8;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
    # Enumerate all the Tornado servers here
    upstream frontends {
        server 127.0.0.1:8000;
        server 127.0.0.1:8001;
        server 127.0.0.1:8002;
        server 127.0.0.1:8003;
    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
    include/path/to/nginx.mime.types;
    default_type application/octet-stream;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
    access_log /var/log/nginx/access.log;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
    keepalive_timeout 65;
    proxy_read_timeout 200;
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    gzip on;
    gzip_min_length 1000;
    gzip_proxied any;
    gzip_types text/plain text/css text/xml
               application/x-javascript application/xml
               application/atom+xml text/javascript;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
    # Only retry ifthere was a communication error, not a timeout
    # on the Tornado server (to avoid propagating "queries of death"
    # to all frontends)
    proxy_next_upstream error;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
    server {
        listen 80;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
        location ^~ /static/ {
            root /path/to/app;
            if($query_string) {
                expires max;
            }
        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
        location / {
            proxy_pass_header Server;
            proxy_set_header Host $http_host;
            proxy_redirect off;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Scheme $scheme;
            proxy_pass http://frontends;
        }
    }
}

对于后端节点，监控的检查请用nginx的check模块 ~

模块下载地址：https://github.com/cep21/healthcheck_nginx_upstreams；模块名称：ngx_http_healthcheck_module

upstream myhttpd {
        server 127.0.0.1:8800weight=5;
        server 127.0.0.1:8801weight=5;
        healthcheck_enabled; 开启健康检查功能
        healthcheck_delay 1000;
对同一台后端服务器两次检测之间的时间间隔，单位毫秒,默认为1000。                healthcheck_timeout 1000;
进行一次健康检测的超时时间，单位为毫秒,默认值2000。
        healthcheck_failcount 3;
对一台后端服务器检测成功或失败多少次之后方才确定其为成功或失败，并实现启用或禁用此服务器
        healthcheck_send "GET/.health HTTP/1.0";
对一台后端服务器检测成功或失败多少次之后方才确定其为成功或失败，并实现启用或禁用此服务器，只支持http 1.0的协议

uwsgi tornado的对比：

有朋友问过我，uwsgi的性能也可以呀。。。

以前我用flask的时候，经常要和uwsgi配合一起用，但是我和群里的人多方面测试压力，uwsgi不是很稳定，经常出现访问错误的情况，看debug也是看不出啥东西来。

这么多的tornado进程该如何开启？

用screen ,用 >/dev/null,用nohup ? 太搓了点吧~

推荐大家用supervisord管理杂乱的tornado服务和别的python服务。

源地址 http://rfyiamcool.blog.51cto.com/1030776/1301410

这里是centos supervisord 的配置

配置supervisor

yum install supervisor
pip install supervisor

echo_supervisord_conf > /etc/supervisord.conf

vim /etc/supervisord.conf

[program:tornado8000]
command=python /ops/tornado8000.py
process_name=%(program_name)s
stdout_logfile=/ops/access.log
stderr_logfile=/ops/error.log
[program:tornado8001]
command=python /ops/tornado8001.py
process_name=%(program_name)s
stdout_logfile=/ops/access.log
stderr_logfile=/ops/error.log
[program:tornado8002]
command=python /ops/tornado8002.py
process_name=%(program_name)s
stdout_logfile=/ops/access.log
stderr_logfile=/ops/error.log
[program:tornado8003]
command=python /ops/tornado8003.py
process_name=%(program_name)s
stdout_logfile=/ops/access.log
stderr_logfile=/ops/error.log

保存完配置后，咱们启动下： run~

/usr/bin/supervisord -c /etc/supervisord.conf

Supervisord安装完成后有两个可用的命令行supervisor和supervisorctl，命令使用解释如下：

• supervisord，初始启动Supervisord，启动、管理配置中设置的进程。

• supervisorctl stop programxxx，停止某一个进程(programxxx)，programxxx为[program:chatdemon]里配置的值，这个示例就是chatdemon。

• supervisorctl start programxxx，启动某个进程

• supervisorctl restart programxxx，重启某个进程

• supervisorctl stop groupworker: ，重启所有属于名为groupworker这个分组的进程(start,restart同理)

• supervisorctl stop all，停止全部进程，注：start、restart、stop都不会载入最新的配置文件。

• supervisorctl reload，载入最新的配置文件，停止原有进程并按新的配置启动、管理所有进程。

• supervisorctl update，根据最新的配置文件，启动新配置或有改动的进程，配置没有改动的进程不会受影响而重启。

• 注意：显示用stop停止掉的进程，用reload或者update都不会自动重启。

然后用装饰器判断状态。。。

@tornado.web.authenticated

代码在这里 ,大家配置自己的系统搞一下。

https://github.com/mmejia27/tornado-memcached-sessions

关于lua的用法，大家可以看看我以前的博文，对于mysql有详细的用法的。

模块代码：

https://github.com/agentzh/lua-resty-mysql

实例代码：

upstream nginxbackend
 {
 drizzle_server 127.0.0.1:3306 dbname=nginx password=youpassword user=yourdbname protocol=mysql charset=utf8;
 drizzle_keepalive max=100 mode=single overflow=reject;
 }
                                                                                                                                                                                                                                                                                                                                                                 
 location = /getuser
 {
 internal;
 set_unescape_uri $user $remote_user;
 set_unescape_uri $passwd $remote_passwd;
 set_quote_sql_str $user $user;
 set_quote_sql_str $passwd $passwd;
 drizzle_query "select count(*) as count from user where user=$user and passwd=$passwd";
 drizzle_pass nginxbackend;
 rds_json on;
 }

总之，我们要多方面的测试压力，才能找到适合自己业务的框架。