python

celery最佳实践

作为一个Celery使用重度用户,看到Celery Best Practices这篇文章,不由得菊花一紧。干脆翻译出来,同时也会加入我们项目中celery的实战经验。

通常在使用Django的时候,你可能需要执行一些长时间的后台任务,没准你可能需要使用一些能排序的任务队列,那么Celery将会是一个非常好的选择。

当把Celery作为一个任务队列用于很多项目中后,作者积累了一些最佳实践方式,譬如如何用合适的方式使用Celery,以及一些Celery提供的但是还未充分使用的特性。

1,不要使用数据库作为你的AMQP Broker

数据库并不是天生设计成能用于AMQP broker的,在生产环境下,它很有可能在某时候当机(PS,当掉这点我觉得任何系统都不能保证不当吧!!!)。

作者猜想为啥很多人使用数据库作为broker主要是因为他们已经有一个数据库用来给web app提供数据存储了,于是干脆直接拿来使用,设置成Celery的broker是很容易的,并且不需要再安装其他组件(譬如RabbitMQ)。

假设有如下场景:你有4个后端workers去获取并处理放入到数据库里面的任务,这意味着你有4个进程为了获取最新任务,需要频繁地去轮询数据库,没准每个worker同时还有多个自己的并发线程在干这事情。

某一天,你发现因为太多的任务产生,4个worker不够用了,处理任务的速度已经大大落后于生产任务的速度,于是你不停去增加worker的数量。突然,你的数据库因为大量进程轮询任务而变得响应缓慢,磁盘IO一直处于高峰值状态,你的web应用也开始受到影响。这一切,都因为workers在不停地对数据库进行DDOS。

而当你使用一个合适的AMQP(譬如RabbitMQ)的时候,这一切都不会发生,以RabbitMQ为例,首先,它将任务队列放到内存里面,你不需要去访问硬盘。其次,consumers(也就是上面的worker)并不需要频繁地去轮询因为RabbitMQ能将新的任务推送给consumers。当然,如果RabbitMQ真出现问题了,至少也不会影响到你的web应用。

这也就是作者说的不用数据库作为broker的原因,而且很多地方都提供了编译好的RabbitMQ镜像,你都能直接使用,譬如这些

对于这点,我是深表赞同的。我们系统大量使用Celery处理异步任务,大概平均一天几百万的异步任务,以前我们使用的mysql,然后总会出现任务处理延时太严重的问题,即使增加了worker也不管用。于是我们使用了redis,性能提升了很多。至于为啥使用mysql很慢,我们没去深究,没准也还真出现了DDOS的问题。

2,使用更多的queue(不要只用默认的)

Celery非常容易设置,通常它会使用默认的queue用来存放任务(除非你显示指定其他queue)。通常写法如下:

@app.task()
def my_taskA(a, b, c):
    print("doing something here...")

@app.task()
def my_taskB(x, y):
    print("doing something here...")

这两个任务都会在同一个queue里面执行,这样写其实很有吸引力的,因为你只需要使用一个decorator就能实现一个异步任务。作者关心的是taskA和taskB没准是完全两个不同的东西,或者一个可能比另一个更加重要,那么为什么要把它们放到一个篮子里面呢?(鸡蛋都不能放到一个篮子里面,是吧!)没准taskB其实不怎么重要,但是量太多,以至于重要的taskA反而不能快速地被worker进行处理。增加workers也解决不了这个问题,因为taskA和taskB仍然在一个queue里面执行。

3,使用具有优先级的workers

为了解决2里面出现的问题,我们需要让taskA在一个队列Q1,而taskB在另一个队列Q2执行。同时指定x workers去处理队列Q1的任务,然后使用其它的workers去处理队列Q2的任务。使用这种方式,taskB能够获得足够的workers去处理,同时一些优先级workers也能很好地处理taskA而不需要进行长时间的等待。

首先手动定义queue

CELERY_QUEUES = (
    Queue('default', Exchange('default'), routing_key='default'),
    Queue('for_task_A', Exchange('for_task_A'), routing_key='for_task_A'),
    Queue('for_task_B', Exchange('for_task_B'), routing_key='for_task_B'),
)

然后定义routes用来决定不同的任务去哪一个queue

CELERY_ROUTES = {
    'my_taskA': {'queue': 'for_task_A', 'routing_key': 'for_task_A'},
    'my_taskB': {'queue': 'for_task_B', 'routing_key': 'for_task_B'},
}

最后再为每个task启动不同的workers

celery worker -E -l INFO -n workerA -Q for_task_A
celery worker -E -l INFO -n workerB -Q for_task_B

在我们项目中,会涉及到大量文件转换问题,有大量小于1mb的文件转换,同时也有少量将近20mb的文件转换,小文件转换的优先级是最高的,同时不用占用很多时间,但大文件的转换很耗时。如果将转换任务放到一个队列里面,那么很有可能因为出现转换大文件,导致耗时太严重造成小文件转换延时的问题。

所以我们按照文件大小设置了3个优先队列,并且每个队列设置了不同的workers,很好地解决了我们文件转换的问题。

4,使用Celery的错误处理机制

大多数任务并没有使用错误处理,如果任务失败,那就失败了。在一些情况下这很不错,但是作者见到的多数失败任务都是去调用第三方API然后出现了网络错误,或者资源不可用这些错误,而对于这些错误,最简单的方式就是重试一下,也许就是第三方API临时服务或者网络出现问题,没准马上就好了,那么为什么不试着重试一下呢?

@app.task(bind=True, default_retry_delay=300, max_retries=5)
def my_task_A():
    try:
        print("doing stuff here...")
    except SomeNetworkException as e:
        print("maybe do some clenup here....")
        self.retry(e)

作者喜欢给每一个任务定义一个等待多久重试的时间,以及最大的重试次数。当然还有更详细的参数设置,自己看文档去。

对于错误处理,我们因为使用场景特殊,例如一个文件转换失败,那么无论多少次重试都会失败,所以没有加入重试机制。

5,使用Flower

Flower是一个非常强大的工具,用来监控celery的tasks和works。

这玩意我们也没怎么使用,因为多数时候我们都是直接连接redis去查看celery相关情况了。貌似挺傻逼的对不,尤其是celery在redis里面存放的数据并不能方便的取出来。

6,没事别太关注任务退出状态

一个任务状态就是该任务结束的时候成功还是失败信息,没准在一些统计场合,这很有用。但我们需要知道,任务退出的状态并不是该任务执行的结果,该任务执行的一些结果因为会对程序有影响,通常会被写入数据库(例如更新一个用户的朋友列表)。

作者见过的多数项目都将任务结束的状态存放到sqlite或者自己的数据库,但是存这些真有必要吗,没准可能影响到你的web服务的,所以作者通常设置CELERY_IGNORE_RESULT = True去丢弃。

对于我们来说,因为是异步任务,知道任务执行完成之后的状态真没啥用,所以果断丢弃。

7,不要给任务传递 Database/ORM 对象

这个其实就是不要传递Database对象(例如一个用户的实例)给任务,因为没准序列化之后的数据已经是过期的数据了。所以最好还是直接传递一个user id,然后在任务执行的时候实时的从数据库获取。

对于这个,我们也是如此,给任务只传递相关id数据,譬如文件转换的时候,我们只会传递文件的id,而其它文件信息的获取我们都是直接通过该id从数据库里面取得。

最后

后面就是我们自己的感触了,上面作者提到的Celery的使用,真的可以算是很好地实践方式,至少现在我们的Celery没出过太大的问题,当然小坑还是有的。至于RabbitMQ,这玩意我们是真没用过,效果怎么样不知道,至少比mysql好用吧。

最后,附上作者的一个Celery Talk https://denibertovic.com/talks/celery-best-practices/

我的编程语言经历

Alan Perlis 说过:“一种不改变你编程的思维方式的语言,不值得去学。”,虽然写了这么多年程序,用了这么多的语言,但我自认还没悟道编程语言如何改变我的思维方式。

几天前,我需要用python来为ledisdb写一个客户端,我突然发现,对于c++,go这种语言,我如果需要实现一个功能,首先想到的是问题是代码应该怎么写。但是当我使用python的时候,我首先考虑的问题是在哪里去找一个库用来解决我的问题。可能这就是使用不同语言带给我的不同思考方式吧。

我的编程语言经历没有那么复杂,没用过很多,但是其实也够我受的了,尤其是在不同语言语法糖之间切换的时候,有种让人崩溃的感觉。没准我应该升级一下我的大脑cpu,使其能够更快速的进行中断处理。

c

我是从大学才开始学习编程的,相比现在的小朋友来说,可以叫做输在了起跑线上面。谁叫以前生活在山区,没机会接触电脑这玩意。

我的第一门编程语言是c,不同于很多童鞋使用的谭浩强神书,我用的是周纯杰的<>,不知道每年有多少同学受到过它的摧残,当然还有那哥们蹩脚的普通话。

在大学里面,很多同学的c的毕业设计都是我帮其完成,但我始终觉得自己仍然是个半吊子,除了c的基础稍微强一点之外,很多方面譬如操作系统,算法等完全不会。(现在随着工作年限的增加让我越发后悔,当初怎么就不稍微学点这些知识,尤其是编译原理。)

我几乎没怎么用c开发过项目,只在tencent可怜的维护过别人的c项目,但至少能看懂c代码,这就够了。

因为大多数时候,我用的是c++,而不是c来解决我的问题。

c++

c++是我工作使用的第一门语言,也是我使用时间最长的一门语言,都七年之痒了,不过还是有点不离不弃的。

以前上学的时候有一句口头禅,叫学好c++,走遍天下都不怕。但是有几个人能把它学好的?所以千万别说自己精通c++,那会被人鄙视的。

我使用c++可以分为三个阶段:

类c阶段

这个阶段主要是我第一份工作的时候,那时候才毕业,c的烙印很深,面向对象除了有个概念,真正是啥完全不知道。所以最喜欢的方式还是写着一堆函数来解决问题,当初VIA身边那帮c++的牛人竟然能忍受我这样的代码,真佩服他们。

面向对象阶段

后来去了第二家公司linekong,开始做游戏,才开始真正意义上的用c++写代码了。

记得最开始去第一家公司面试的时候,被问了啥是面向对象,当时不假思索的答了继承,多态和封装。

啥叫封装?整一个class,把该包的都包了,一个同事曾告诉我,他见过有几万行代码的class,看来我这个几千行的太小儿科了。

啥叫继承?先来一个父类,干脆叫bird,有一个fly方法,再来一个子类,叫duck吧,继承了bird,不过duck会fly吗?一个父类不够,再来一个,搞个多重继承,什么?出现了菱形继承,那干脆在来一个virtual继承得了。

啥叫多态?不就是virtual function,然后父类指针能在运行时根据实际情况调用相应的子类实现。那c++的多态是怎么实现的?看看<<深度探索c++对象模型>>不就行了。

这段时间,可以算是我写c++代码最多的时候,都快写到吐了,尤其还要忍受那龟速的编译。我们竟然都实现了直接通过汇编改c++的虚表,使其调用自己的函数这种变态的东西。在那时候我就得出结论,如果不想早死,尽量别用这个东西写代码。可是到如今我都在不停的慢性自杀。

现代C++阶段

不知道从什么时候开始,我突然觉得我应该来点modern c++的编写方式了,c++0x都出了,还不玩一下就晚了。当然新特性那么多,不可能全部都拿来用的,Bjarne Stroustrup貌似都说过,c++0x应该算是另一门语言了。

于是哥就走上了伪modern c++之路,class还是需要的,不然数据怎么封装。继承吗,比重减轻吧,最好采用面向接口的编程方式。而多态,能不用就不用吧,反而觉得bing + function的方式实现的delegate模型反而更方便,没准也更酷哟。

shared_ptr,weak_ptr是需要用的了,c++没有gc,所以一套好的内存管理方式是必不可少的,每次new之后还要记得delete也比较烦,最严重的是可能忘记那就内存泄露了。

于是,我就自认为我进化了,最典型的例子就是我写的高性能网络库libtnet,感觉很modern了。

lua

最开始知道lua,是云风那本编程感悟的书,当时可是菊花一紧,觉得这东西是啥,为什么能跟c结合到一起使用?

后来自己开发游戏了,才发现lua真的是一门很强大的语言,短小精悍,嵌入简单,性能超强,完全是作为游戏脚本语言开发的不二人选。不过我最开始使用lua的经历不怎么happy,最开始就是接手了一个c++与lua的粘合层库,关于这个库的传说,见这里Lua 不是 C++。后来,在踩了无数个坑,填了无数个坑之后,我终于弄得相对稳定了。貌似现在我以前的同事还在使用,不过正如我在lua c函数注册器中说明的那样,对于语言的交互,简单一点才好。现在以前做的游戏已经开源,见这里,那个传说中的蛋疼粘合层也见了世面。当然,我可不会告诉你们好多搓代码是我写的。

后来,在现在的公司,因为项目的需要,我们急需解决python的很多性能大坑问题,于是我开始推广使用openresty,一个用lua包裹的nginx,用了之后,腰不痛了,腿不痛了,性能妥妥的。

因为lua,我第一次尝到了在代码里面直接写配置的便捷,用一个table搞定,相比起来,c++处理ini,json这些的弱爆了。另外,动态语言的热更新机制使其代码升级异常方便,不过你得非常小心lua的闭包,没准你重新加载了代码运行还是老样子。

lua是一个动态语言,所以不用我们管内存释放问题,但是仍然可能会有引用泄露,在开发游戏的时候,为了解决我们程序lua内存泄露的问题,我曾经干过直接从_G递归遍历,扫描整个lua数据的事情。相比在c++使用valgrind这些程序的工具,lua配套的东西还是太小儿科了。

lua的调试也是一个大头问题,我曾今写过几个lua的调试器,例如这个,甚至都支持了类似gdb那样ctrl+c之后动态的设置断点,可是仍然没觉得比gdb方便,所以多数时候,我都是写log为主。

python

虽然小时候吃过很多蛇,但是蟒蛇可是从来没吃过的,现在看来python味道还不错。

我是来了kingsoft之后才开始正式使用python的。对于为啥使用python,我曾跟拉我进来的技术老大讨论过,他直接就说,开发快速,上手容易。

python开发的快速很大程度是建立在丰富的第三方库上面的,我们也使用了很多库,譬如tornado,gevent,django等,但是正如我最开始说的,因为我们有太多的选择,面对一个问题的时候,往往考虑的是如何选择一个库,而不是自己如何实现,这其实在某种程度上面使得很多童鞋知其然而不知其所以然。这点,lua可能是另一个极端,lua的定位在于嵌入式和高性能,所以自然地,你得自己动手造轮子(当然,现在也有很多好的第三方库了),虽然有时候写起来很不方便,但是至少自己很清楚程序怎么跑的。

当然,我绝对没有贬低python的意思,我很喜欢这门语言,用它来开发了很多东西,同时也知道很多公司使用python构建了很多大型稳定的系统(我们的产品应该也算吧)。

只是现在我越发觉得,看起来简单的语言,如果没有扎实的基本功底,写出来的东西也很烂,而python,恰恰给人放了一个很大的烟雾弹,你以为它有多容易,其实它是在玩你。

go

好了,终于开始说go了,let’s go!!!

我使用go的历史不长,可能也就一年多,但是它现在完全成了我最爱的语言,go具有了python开发的迅速,同时也有着c运行的性能。(当然,还是有差距的!)

网上有太多的语言之争,包括go,有人恨,有人爱。但萝卜白菜,各有所爱,对于我来说,能帮我解决问题,让我用着舒服的语言就是好语言。

go非常适用于服务端程序开发,比起用c++开发,我陡然觉得有一种很幸福的感觉,譬如对于网络编程,在c++里面,我需要自己写epoll的事件处理,而且这种异步的机制完全切分了整个逻辑,使得代码不怎么好写,我在开发libtnet的时候感触尤其深刻。但是在go里面,因为天生coroutine的支持,使得异步代码同步化了,非常利于代码的编写。

现在我的主要在项目中推动go的使用,我们已经用go搭建了一个高性能的推送服务器,后续还有几个系统会上线,而且开发的进度并不比使用python差,另外也很稳定,这让我对go的未来充满了期待。

我也用go写了很多的开源程序,也算是拿的出手了,譬如:

  • ledisdb:一个基于leveldb的提供类似redis高级数据结果的高性能NoSQL,真挺绕口的,简单点就是一个高性能NoSQL。
  • Mixer:一个mysql-proxy,现在支持通用的mysql命令代理,读写分离,以及自动主备切换。后续将要参考vitess支持分区,为此一直在恶补编译原理的知识。
  • go-log:一个类似python log模块的东西,支持多种handler,以及不同的log级别。

还有一些,可以参考我的github,譬如moonmq(一个高性能push模型的消息服务器),polaris(一个类似tornado的restful web框架),因为go,我开始热衷于开源了,并且认识了很多的好基友,这算得上一个很大的收获吧。

其它

好了,说完了上面我的长时间使用语言(至少一年以上),我也用了很多其他的语言,现在虽然使用时间比较短,但不排除后续会长久使用。

Objective-C

因为我家终于有了苹果三件套,所以决定开发app了,首要的任务就是得学会使用Objective-C。我承认这真是一门奇葩的语言,如果没有xcode的自动补齐,我真不知道写起来是神马样的感觉。

而且第一次见到了一门推荐写函数名,变量名就像写文章的语言,至少我写c++,go这些的一个函数名字不会写成一个句子。

我现在在自学iOS的开发,慢慢在整出点东西,毕竟答应给老婆的iphone做点啥的。后续干脆就写一个《小白学iOS》系列blog吧(如果我有精力!),反正对于iOS,我真是一个小白。

java

好吧,我也在android上面写过程序,build到我的S3上面去过,对于java,我的兴趣真不大,貌似自己还买过两本《java编程思想》,那时候脑袋铁定秀逗了。

但是不得不承认,java在服务器领域具有非常强的优势,很多很多的大企业采用java作为其服务器的编程语言。典型的就是淘宝,据传杭州的很多软件公司都不用java的,你用java就等于给淘宝培养人才了。(不过我发现他们很多基础组件譬如TFS这些的可是c++的哟!)

java是门好语言,只是我个人不怎么喜欢,可能我就是太小众了,只对c语言体系的感兴趣。所以很多公司我去不了,哈哈!

erlang

受《计算机程序的构造与解释》影像,我一直想学一门函数式编程语言,最开始玩的是elisp,谁叫以前我是个深度的emacser(后来竟然变成了一个vimer,再后来就是sublimer,这世界真神奇)。

后来还是决定好好学习一下erlang,也第一次领略到了函数式编程的魅力。自己唯一用erlang开发过的东西就是bt下载的客户端,不过后来发现用处不大就没继续进行下去了。(好吧,我承认当时想下岛国的东西)

学习erlang之后最大的优势在于现在能看懂很多优秀的erlang项目,譬如我在做moonmq以及公司的推送服务的时候,研究了rabbitmq,这玩意可是用erlang写的,而我竟然还能看懂,太佩服我了。

还有么?

想想自己还学了哪些语言?貌似没了,不知道awk算不算一门。看来我会得语言真不多。

后续可能会学的

逆水行舟,不进则退,计算机发展这么迅速,我也需要不断提升自己,其中学习一门新的语言可能是一个很好的提升途径,至少能为我打开一扇门。譬如,如果掌握了日文,就能更好的理解岛国片的精髓。我不会日文,所以还是个门外汉。

ruby

ruby是一门很优雅的语言,很多大神级别的人物推荐,github貌似也是ruby的幕后推手。

因为ROR的兴起,使得ruby更加流行。看来,一个好的框架库对于语言的推广帮助真挺大的。相比而言,python有django,tornado等,光选择适合自己的就得费点时间。

ruby可以算是一门完全面向对象的语言,连number这种的都是对象,而且看了几本Matz的书,觉得这哥们挺不错的,对技术的感悟很深,所以更让我有兴趣去了解ruby了。

javascript

作为一个技术人员,没一个自己的个人网站怎么行,我的阿里云都是包年买的(明年还是买国外的vps吧),自己的个人站点还无影无踪。

好吧,我完全不会javscript,看着css就头疼,没准我从一开始想自己写代码搭建个人站点这个步子就迈的太大,扯着蛋了。如果先用一个开源的框架搭建起来,再自己调整完善,可能会更好。但无论怎样,javascript这门语言还是要学习了解的,尤其是以后随着html5的流行,加之node.js疯狂流行,这门语言也会愈发的发光发热。

C Sharp

其实本来不准备跟ms的东西扯上关系的,虽然vs是一个很强大的开发工具,但是我自从换成mac之后就不准备再迁回windows。

只是c#我可能是必须要学会的,因为那个坑爹的unity3d,虽然unity3d也提供了其它语言的支持(譬如伪javascript),但是大量的开发者还是选用了c#,至少在中国我问过很多朋友,都妥妥的用c#,既然这样,我也只能考虑学习使用了。

至于我为啥蛋疼的想玩unity3d,毕竟干了很多年游戏开发,一直有自己弄一个简单小游戏的梦想,还是妥妥的unity3d吧。

自己造一个?

语言千千万,我不可能全部学会的,而且以后没准因为业务的需要,没准都会自己造一门语言,也就是DSL。不过这个貌似还离我比较遥远,编译原理的东西太差了(说多了都是泪呀)。自己写词法分析还成,后面就菜了。这也是Mixer一直没啥进展的原因。不过已经买了龙书,在学习屠龙秘籍,希望成为顶尖高手吧。

后记

写了这么多,看来随着年岁的增加,越来越啰嗦了。不是有一句古话:吾生也有涯,而知也无涯 。以有涯随无涯,殆已。不过不停地追逐不也是乐趣一件?

只是,现在我首先要做的就是向我老婆申请资金升级电脑了吧!

为什么使用Go

这里,我并不打算引起语言争论的口水仗,我并不是什么大牛,对语言的造诣也不深,只是想通过自己实际的经历,来说说为什么我在项目中选择go。

其他语言的经历

C++

在接触go之前,我已经有多年的c++开发经验。主要用在游戏服务端引擎开发以及P2P上面,那可是一段痛并快乐的时期,以至于我看到任何的程序钉子问题都觉得可以用c++这把锤子给敲定。但是对于互联网项目开发来说,除非你的团队整体的c++技术水平nb,并且有很强的代码规范,不然真可能是一场灾难,更别说我们现有团队几乎没其他人会这玩意了。

本来,我打算在现有项目中的推送系统中使用c++,并用业余时间写好了一个网络底层库libtnet,但后来还是决定打住,因为没有人能够协助我开发。令我比较欣慰的是,libtnet有一个游戏公司在使用,现处于内部测试阶段,即将放出去,我倒是很期待他们的好消息。

Lua

在做游戏的过程中,我也学会了lua这门语言,并且还有幸接触并完善了云风在Lua 不是 C++中提到的那个恐怖的lua,c++粘合层。

lua真的是一门非常好的语言,性能高,开发快速。不光游戏公司大量使用,在互联网领域,因为openresty的流行,一些公司(包括我们)也开始在web端使用lua进行开发。(颇为自豪的是还给openresty反馈过几个bug)

但是,lua因为太短小精悍,功能库并不多,很多需要自己去实现,而且,写出高性能,高质量lua代码也并不是很容易的事情。另外,因为其动态语言的特性,我们也栽了不少坑,这个后续在详说。

Python

在我来现有的团队之前,他们就已经使用python进行整个系统的开发,甚至包括客户端GUI(这对客户端童鞋当时就是一个灾难,后来换成Qt就舒爽了)。

python的好处不必说,从数不清的公司用它进行开发就知道,库非常丰富,代码简洁,开发迅速。

但是,在项目中经过两年多python开发之后,我们渐渐出现了很多问题:

  • 性能,python的性能是比较偏低的,对于很多性能热点代码,通常都会采用其他的方式实现。在我们的项目中,需要对任何API调用进行签名认证,认证服务我们开始使用的是tornado实现,但很不幸运的是,放到外网并没有顶住压力。所以我们引入openresty,专门用以解决性能问题。
  • 部署,python的库因为太丰富了,所以我们的童鞋引入了很多的库,个人感觉在pythoner的世界里面,可没有造轮子的兴趣。有时候发版本的时候,我们会因为忘记安装一个库导致程序无法运行。这可能跟我们团队没有成熟运维经验有关,后续通过salt,puppet这种发布工具应该能解决。
  • 质量,通常我们都认为,因为python代码的简洁,我们很容易的能写出高质量的代码,但是如果没有好的代码控制手段,用python也仍然能写出渣的代码,我甚至觉得因为其灵活性,可能会更容易写出烂的代码。这可以说是我们团队的教训。

这里,我并没有喷python的意思,它真的是一门好语言,我能够通过它快速的构建原型,验证我的想法,而且还一直在使用。只是在项目中,我们的一些疏忽,导致代码不可控了,到了不得不重构的地步了。

Why GO?

前面说了我的语言经历,以及项目到了重构地步的原因,但是为什么会是go呢?我们可以有很多其他的选择,譬如java,erlang,或者仍然采用python。我觉得有很多因素考量:

  • 静态,go是一门静态语言,有着强类型约束,所以我们不太可能出现在python中变量在运行时类型不匹配(譬如int + string)这样的runtime error。 在编译阶段就能够帮我们发现很多问题,不用等到运行时。(当然,这个静态语言都能做到)

  • 代码规范,很多人都比较反感go强制的编码规范,譬如花括号的位置。但我觉得,就因为强制约定,所以大家写出来的go代码样子都差不多,不用费心再去深究代码样式问题。而且我发现,因为规范统一,我很容易就能理解别人写的代码。

  • 库支持,go的库非常丰富,而且能通过go get非常方便的获取github,google code上面的第三方库(质量你自己得担着了),再不行,用go自己造轮子也是很方便的,而且造的轮子通常都比较稳定。

  • 开发迅速,不得不说,当你习惯用go开发之后,用go开发功能非常的快,相对于静态语言c++,开发的效率快的没话说,我觉得比python都不差,而且质量有保证。我们花了不到一个星期进行推送服务核心功能开发,到现在都没怎么变动,稳定运行。

  • 部署方便,因为是静态的,只需要build成一个可运行程序就可以了,部署的时候直接扔一个文件过去,不需要像python那样安装太多的依赖库。

GO特性

go现在的这个样子,有些人喜欢,有些人不喜欢,我无法知道为啥google那帮人把go设计成这样,但是我觉得,既然存在,就有道理,我只需要知道什么该用,什么不该用就可以了。

gc

GO提供了gc,这对于c++的童鞋来说,极大的减少了在内存上面犯错的机会,只是go的gc这个效率还真的不好恭维,比起java来说,还有很大的提升空间。

所以有时候写代码,我们还得根据tuning来提升gc的效率,譬如采用内存池的方式来管理大块的slice分配,采用no copy的方式来进行string,slice的互转。

不过go1.3貌似gc性能有了很大的改善,这点让我比较期待。

defer

go的defer其实是一个让人又爱又恨的东西,对于防止资源泄露,defer可是一个很不错的东西,但是滥用defer可是会让你面临很严重的内存问题,尤其是像下面的代码:

for {
    defer func(){
        //do somthing
    }
}

别以为go会在调用完成defer之后就好好的进行gc回收defer里面的东西,在我们进行内存profile的时候,发现大量的内存占用都是defer引起的。所以使用起来需要特别谨慎。

但我觉得,这个go应该会稍微改善,在go1.3里面,也有了对defer的优化。

error

也许error是一个让人争议很大的东西,现代方式的exception那里去呢?但是我觉得error能够非常明确的告诉使用者该函数会有错误返回,如果使用exception,除非文档足够详细,我还真不知道哪里就会蹦出一个异常了。

只是,go又提供了类似exception的defer,panic,recover,这是要闹哪出。

其实这篇文章我觉得已经解释的很好了,go程序的惯例是对外的API使用error,而内部错误处理可以用defer,recover和panic来简化流程。

其实这倒跟我一贯的编程准则对应,在团队在用python进行开发的时候,我们都明确要求库对外提供的API需要使用返回值来表示错误,而在内部可以使用try,catch异常机制。

interface

go提供了interface来进行抽象编程。何谓接口,最通常的例子就是鸭子的故事,“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子“。

在go里面,interface就是一堆方法的集合,如果某个对象实现了这些方法,那么该对象可以就算是该interface。使用interface,我们可以很方便的实现非侵入式编程,进行模块功能的替换。

对于长时间沉浸c++和python的童鞋来说,一下子要用interface来解决抽象问题,可能会很不适应。但当习惯之后,你会发现,其实interface非常的灵活方便。

写到后面

在使用的时候,我们需要知道go到底适用在什么地方,譬如我们现在也就将API服务使用go重构,我们可没傻到用go去替换openresty。

总之,go是一门很新的语言,国内也已经有很多公司开始吃这个螃蟹,也有成功的例子了,而我们也正开始了这段旅程。

学习Tornado:基本

前言

在python里面,有许多web framework。对于我来说,因为很长一段时间都在使用tornado,所以有了一些心得体会。

在这里,要说明一下,tornado采用的是2.4版本。

架构

tornado是一个典型的prefork + io event loop的web server架构,Alt text

从图上可以看出,tornado的架构是很简单清晰的。

  • ioloop是tornado的核心,它就是一个io event loop,底层封装了select,epoll和kqueue,并根据不同的平台选择不同的实现。
  • iostream封装了non-blocking socket,用它来进行实际socket的数据读写。
  • TCPServer则是通过封装ioloop实现了一个简易的server,同时我们也在这里进行prefork的处理
  • HTTPServer则是继承TCPServer实现了一个能够处理http协议的server。
  • Application则是实际处理http请求的模块,HTTPServer收到http请求并解析之后会通过Application进行处理。
  • RequestHandler和WebSocketHandler则是注册给Application用来处理对应url的。
  • WSGIApplication则是tornado用于支持WSGI标准的接口,通过WSGIContainer包装共HTTPServer使用。

例子

通过上面的分析,直到tornado的架构是很简单明了的,所以自然我们也能够通过简短的一些代码就能搭建起自己的http server。以一个hello world开始:

import tornado.web 
import tornado.httpserver 
import tornado.ioloop 

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write('Hello World')

application = tornado.web.Application([
    (r"/", MainHandler),
])
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8080)
tornado.ioloop.IOLoop.instance().start()

流程很简单,如下:

  • 定义了一个MainHandler,该handler用来处理对应url
  • 生成一个Application实例,并设置url dispatch规则,(r”/“, MainHandler)就是一个规则,第一个pattern用来表明需要处理的url,内部会使用正则匹配,第二个就是对应url处理的handler
  • 生成一个HTTPServer实例,使用Application进行构造,这样HTTPServer处理的http请求就会转给application处理。
  • HTTPServer监听一个端口8080,该listen socket会加入ioloop中,用于监听连接的建立。
  • ioloop启动,程序进入io event loop模式。

当ioloop start之后,服务器就启动了,后续就是一个http server最基本的流程处理了。

ReuqestHandler

pattern and handler

从上面例子可以看出,搭建一个http server很简单,所以我们重点只需要考虑的是如何处理不同的url http请求,这也就是RequestHandler需要做的事情。

我们在创建Application的时候,会指定不同的url pattern需要处理的handler。如下:

import tornado.web 
import tornado.httpserver 
import tornado.ioloop 

class Index1Handler(tornado.web.RequestHandler):
    def get(self):
        self.write('Index1')

class Index2Handler(tornado.web.RequestHandler):
    def get(self, data):
        self.write('Index2')
        self.write(data)

application = tornado.web.Application([
    (r"/index1", Index1Handler),
    (r"/index2/(\w+)", Index2Handler),
])

http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8080)
tornado.ioloop.IOLoop.instance().start()

在上面的例子中,我们有两个handler,分别处理url path为index1和index2的情况,对于index2来说,我们看到,它后面还需要匹配一个单词。我们通过curl访问如下:

$ curl http://127.0.0.1:8080/index1
index1

$ curl http://127.0.0.1:8080/index2/abc
index2abc

http method

RequestHandler支持任何http mthod,包括get,post,head和delete,也就是说,tornado天生支持restful编程模型。

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        pass

    def post(self):
        pass

    def head(self):
        pass

    def delete(self):
        pass

从上面可以看到,我们只需要在handler里面实现自己的get,post,head和delete函数就可以了,这点再次说明tornado的简洁与强大。

后续next

这里,只是简单了介绍了一下tornado,后续将会从template,asynchronous,security等分别介绍一下。希望通过这个能让自己对tornado的理解更加深刻,同时也为后续使用其他python web framework做参考。

学习Tornado:异步

why asynchronous

tornado是一个异步web framework,说是异步,是因为tornado server与client的网络交互是异步的,底层基于io event loop。但是如果client请求server处理的handler里面有一个阻塞的耗时操作,那么整体的server性能就会下降。

def MainHandler(tornado.web.RequestHandler):
    def get(self):
        client = tornado.httpclient.HttpClient()
        response = client.fetch("http://www.google.com/")
        self.write('Hello World')

在上面的例子中,tornado server的整体性能依赖于访问google的时间,如果访问google的时间比较长,就会导致整体server的阻塞。所以,为了提升整体的server性能,我们需要一套机制,使得handler处理都能够通过异步的方式实现。

幸运的是,tornado提供了一套异步机制,方便我们实现自己的异步操作。当handler处理需要进行其余的网络操作的时候,tornado提供了一个async http client用来支持异步。

def MainHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        client = tornado.httpclient.AsyncHTTPClient()
        def callback(response):
            self.write("Hello World")
            self.finish()

        client.fetch("http://www.google.com/", callback)

上面的例子,主要有几个变化:

  • 使用asynchronous decorator,它主要设置_auto_finish为false,这样handler的get函数返回的时候tornado就不会关闭与client的连接。
  • 使用AsyncHttpClient,fetch的时候提供callback函数,这样当fetch http请求完成的时候才会去调用callback,而不会阻塞。
  • callback调用完成之后通过finish结束与client的连接。

asynchronous flaw

异步操作是一个很强大的操作,但是它也有一些缺陷。最主要的问题就是在于callback导致了代码逻辑的拆分。对于程序员来说,同步顺序的想法是一个很自然的习惯,但是异步打破了这种顺序性,导致代码编写的困难。这点,对于写nodejs的童鞋来说,可能深有体会,如果所有的操作都是异步,那么最终我们的代码可能写成这样:

def MainHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        client = tornado.httpclient.AsyncHTTPClient()
        def callback1(response):

            def callback2(response):
                self.write("Hello World")
                self.finish()
            client.fetch("http://www.google.com", callback2)

        client.fetch("http://www.google.com/", callback1)

也就是说,我们可能会写出callback嵌套callback的情况,这个极大的会影响代码的阅读与流程的实现。

synchronous

我个人认为,异步拆散了代码流程这个问题不大,毕竟如果一个逻辑需要过多的嵌套callback来实现的话,那么我们就需要考虑这个逻辑是否合理了,所以异步一般也不会有过多的嵌套层次。

虽然我认为异步的callback问题不大,但是如果仍然能够有一套机制,使得异步能够顺序化,那么对于代码逻辑的编写来说,会方便很多。tornado有一些机制来实现。

yield

在python里面如果一个函数内部实现了yield,那么这个函数就不是函数了,而是一个生成器,它的整个运行机制也跟普通函数不一样,举一个例子:

def test_yield():
    print 'yield 1'
    a = yield 'yielded'
    print 'over', a

t = test_yield()
print 'main', type(t)
ret = t.send(None)
print ret
try:
    t.send('hello yield')
except StopIteration:
    print 'yield over'

输出结果如下:

main <type 'generator'>
yield 1
yielded
over hello yield
yield over

从上面可以看到,test_yield是一个生成器,当它第一次调用的时候,只是生成了一个Generator,不会执行。当第一次调用send的时候,生成器被resume,开始执行,然后碰到yield,就挂起,等待下一次被send唤醒。当生成器执行完毕,会抛出StopIteration异常,供外部send的地方知晓。

因为yield很方便的提供了一套函数挂起,运行的机制,所以我们能够通过yield来将原本是异步的流程变成同步的。

gen

tornado有一个gen模块,提供了Task和Callback/Wait机制用来支持同步模型,以task为例:

def MainHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    @tornado.gen.engine
    def get(self):
        client = tornado.httpclient.AsyncHTTPClient()
        response = yield tornado.gen.Task(client.fetch, "http://www.google.com/")
        self.write("Hello World")
        self.finish()

可以看到,tornado的gen模块就是通过yield来进行同步化的。主要有如下需要注意的地方:

  • 使用gen.engine的decorator,该函数主要就是用来管理generator的流程控制。
  • 使用了gen.Task,在gen.Task内部,会生成一个callback函数,传给async fetch,并执行fetch,因为fetch是一个异步操作,所以会很快返回。
  • 在gen.Task返回之后使用yield,挂起
  • 当fetch的callback执行之后,唤醒挂起的流程继续执行。

可以看到,使用gen和yield之后,原先的异步逻辑变成了同步流程,在代码的阅读性上面就有不错的提升,不过对于不熟悉yield的童鞋来说,开始反而会很迷惑,不过只要理解了yield,那就很容易了。

greenlet

虽然yield很强大,但是它只能挂起当前函数,而无法挂起整个堆栈,这个怎么说呢,譬如我想实现下面的功能:

def a():
    yield 1

def b():
    a()

t = b()
t.send(None)

这个通过yield是无法实现的,也就是说,a里面使用yield,它是一个生成器,但是a的挂起无法将b也同时挂起。也就是说,我们需要一套机制,使得堆栈在任何地方都能够被挂起和恢复,能方便的进行栈切换,而这套机制就是coroutine。

最开始使用coroutine是在lua里面,它原生提供了coroutine的支持。然后在使用luajit的时候,发现内部是基于fiber(win)和context(unix),也就是说,不光lua,其实c/c++我们也能实现coroutine。现在研究了go,也是内置coroutine,并且这里极力推荐一篇slide

python没有原生提供coroutine,不知道以后会不会有。但有一个greenlet,能帮我们实现coroutine机制。而且还有人专门写好了tornado与greenlet结合的模块,叫做greenlet_tornado,使用也很简单

class MainHandler(tornado.web.RequestHandler):
    @greenlet_asynchronous
    def get(self):
        response = greenlet_fetch('http://www.google.com')
        self.write("Hello World")
        self.finish()

可以看到,使用greenlet,能更方便的实现代码逻辑,这点比使用gen更方便,因为这些连写代码的童鞋都不用去纠结yield问题了。

总结

这里只是简单的介绍了tornado的一些异步处理流程,以及将异步同步化的一些方法。另外,这里举得例子都是网络http请求方面的,但是server处理请求的时候,可能还需要进行数据库,本地文件的操作,而这些也是同步阻塞耗时操作,同样可以通过异步来解决的,这里就不详细说明了。

学习Tornado:安全

在web编程中,安全性是我们都必须面临的一个问题,包括cookie伪造,xsrf攻击等。tornado作为一个web framework,在安全性方面也提供了很多功能,这里简单介绍一下。

cookie

在web编程中,浏览器经常使用cookie来保存相关用户信息,用于与server交互,但是cookie有很多安全问题,譬如cookie伪造。cookie有很多方式被修改,javascript,flash,以及browser plugin等,所以首先需要保证cookie不被修改。

tornado提供了secure cookie机制来保证cookie不被修改。tornado使用一个密钥用来给cookie进行签名,用来保证cookie只能被服务器修改。因为密钥只有tornado server知道,所以其它应用程序是没办法修改cookie的值。

tornado使用set_secure_cookie和get_secure_cookie来设置和读取browser的cookie。使用secure cookie,只需要在tornado启动的时候设置cookie_secret就行了,如下:

import tornado.web 
import tornado.httpserver 
import tornado.ioloop 

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        count = self.get_secure_cookie('count')
        count = (int(count) + 1) if count else 1

        self.set_secure_cookie('count', str(count))

        self.write(str(count))

settings = {
    'cookie_secret' : 'S6Bp2cVjSAGFXDZqyOh+hfn/fpBnaEzFh22IVmCsVJQ='
}

application = tornado.web.Application([
    (r"/", MainHandler),
], **settings)

http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8080)
tornado.ioloop.IOLoop.instance().start()

cookie_secret的生成如下:

import base64
import uuid
base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes)

httponly

为了防止cross-site scripting attack,tornado可以再设置cookie的时候增加httponly字段,这样该cookie就不能够被javascript读取。同时,为了更高的安全性,可以给cookie设置secure属性,这个跟先前讨论的set_secure_cookie不一样,上面那个是对cookie进行加密签名,保证不被修改,而这个则是让browser通过ssl传输cookie。启用这些功能很简单,只需要在设置cookie的时候处理。

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.set_cookie('count1', '1', httponly = True, secure = True)
        self.set_secure_cookie('count2', '2', httponly = True, secure = True)

XSRF

上面介绍的方法虽然能够保证cookie的安全,但是还是防止不了XSRF攻击。为了防止XSRF攻击,首先设计web服务的时候就需要考虑http method的side effects。按照restful的编程模型,get只能用来获取数据,post才会去修改数据,这样就能在很大的程度上面防止XSRF,因为对于通常情况来说,XSRF攻击就是通过设置img的src为一个恶意的get请求,只要我们的get不会进行数据修改,自然就能防止。

但是一些恶意的操作仍然能够发送post请求来进行攻击,譬如通过HTML forms或者XMLHTTPRequest API,所以为了防止post这种的攻击,我们需要一些额外的机制。

tornado提供了一个XSRF保护机制,原理很简单,就是在post提交数据的时候额外加入一个_xsrf字段,这个字段的值是从secure cookie里面获取的,因为其它的应用程序获取不到这个cookie的值,所以我们能够保证post的安全性。开启xsrf protection也很简单。

settings = {
    'cookie_secret' : 'S6Bp2cVjSAGFXDZqyOh+hfn/fpBnaEzFh22IVmCsVJQ=',
    'xsrf_cookies' : True
}

application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/purchase", PurchaseHandler)
], **settings)

在post提交的form里面,我们只需要设置如下:

<form action="/purchase" method="POST">

    <input type="submit" value="同意" name="agree"/>
</form>

User Authentication

tornado还提供了用户认证功能,当用户登录之后,会将用户的相关信息保存到一个地方,通常是在cookie里面。当用户的cookie过期,再次访问web服务的时候就会被重定向到登陆页面。

要实现上述功能,只需要重载get_current_user函数,配置login_url和使用authenticated decorator就行了。如下:

class BaseHandler(tornado.web.RequestHandler):
    def get_current_user(self):
        return self.get_secure_cookie('username')

class LoginHandler(BaseHandler):
    def get(self):
        str = '''<body><form action="/login" method="POST">
                UserName: <input type="text" name="username" />
                          <input type="submit" value="Login" />
                </form></body>'''
        self.write(str)

    def post(self):
        self.set_secure_cookie('username', self.get_argument('username'))
        self.redirect('/')

class MainHandler(BaseHandler):
    @tornado.web.authenticated
    def get(self):
        user = self.current_user
        self.write('hello ' + user)

class LogoutHandler(BaseHandler):
    def get(self):
        self.clear_cookie('username')
        self.redirect('/')

settings = {
    'cookie_secret' : 'S6Bp2cVjSAGFXDZqyOh+hfn/fpBnaEzFh22IVmCsVJQ=',
    'login_url' : '/login'
}

application = tornado.web.Application([
    (r'/', MainHandler),
    (r'/login', LoginHandler),
    (r'/logout', LogoutHandler)
], **settings)

http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8080)
tornado.ioloop.IOLoop.instance().start()

总结

web安全一直是一个非常严重的问题,我们在写代码的时候一定要注意,这里有一篇如何写安全web的Guide。tornado虽然提供了一些安全机制,但是仍然不能完全保证绝对安全性,所以很多时候就需要我们决定我所写的服务到底应该有什么样的安全级别,从在这个级别下面如何保证安全性就可以了。

mtunnel - a simple http tunnel

介绍

mtunnel是一个简易的http隧道工具,使用python实现,基于tornado。

为了解决远端用户服务器的一些问题,我们需要远程连接到用户的服务器上面,但因为企业安全性问题,外部根本不可能访问相关服务器,只能通过用户的本地机器去访问,但是用户本地机器也在内网环境下面,外部不能直接连接。

因为用户的机器在内网环境下面,也不可能通过通常的代理去连接。所以比较好的方式就是通过一台双方都能访问的公网服务器,来交换双方的数据。

mtunnel通过http tunnel的方式来进行数据的交互。它将双方交互的数据封装到http的body里面,通过http协议进行传输。这样有几个好处:

  • 不用关心交互的具体协议,mtunnel只是将双方交互的所有信息完全封装到http body里面进行传递。
  • http一般不会被企业的网络安全规则给屏蔽,内网穿透性更好。

假设,企业服务器启动了sshd,而我们这边使用putty。流程如下:

image

  • putty直接将数据发送给forward proxy,由forward proxy将数据通过http body发送给server。
  • server收到数据之后将其放置在一个buffer中。如果reverse proxy这时候已经连接到server,则直接将数据发送给reverse proxy。
  • reverse proxy定时去server获取数据,如果有则将其发送给sshd。
  • sshd返回的数据同样流程返回给putty。

使用

mtunnel分为3个部分,与putty交互的forward proxy,与sshd交互的reverse proxy以及负责双方数据中转的server。

start server

    python server.py -p 8888

假设sever的ip地址为10.20.187.118,监听port为8888。

start reverse proxy

因为我们需要通过用户本地机器去访问服务器,所以首先必须用户同意让我们访问,也就是他需要在本地启动reverse proxy。

    python rproxy.py -host 10.20.189.241 -p 22 --server 10.20.187.118:8888

host和port连接的是sshd的ip和port,而server则是服务器的地址。
reverse proxy如果成功连接上了server,则会获取一个channel id。后续所有的通信都必须通过该channel id进行。

start forward proxy

    python fproxy.py --server 10.20.187.118:8888 --channel 112122 -p 8889

我们在本地启动forward proxy,监听本地8889端口,server为服务器的地址,而channel则是用户启动reverse proxy之后获取的channel id,由用户负责告诉我们。

use

当做了上述操作之后,我们只需要启动putty,连接forward proxy。然后putty就能与远端的sshd交互了。

远程协助?

为什么不使用QQ远程协助这种类似功能?主要有以下几点原因:

  • QQ远程协助能看到用户本地机器的很多信息,企业用户对于安全性问题比较敏感。
  • 网络问题,现在很多企业的网络环境非常不好,我们就碰到过太多次远程的时候网络坑爹造成完全无法工作的情况。

后续方向

现在的版本只是一个最基本的版本,很多问题没有考虑,后续主要考虑以下几个方面:

  • 安全性,尤其要保证channel id的安全性。后续考虑使用签名机制等。
  • 网络容错,还没怎么很好的处理网络出问题的情况,譬如网络断开等。
  • P2P,数据都走server会有延时,稳定等问题,如果能够P2P互通,就很强大了。

代码在这里,该版本只是笔者使用python实现的一个非常基础的版本,很多地方存在不足,后续会慢慢完善。

版权声明:自由转载-非商用-非衍生-保持署名 Creative Commons BY-NC-ND 3.0