千万个美丽的未来，抵不上一个温暖的现在，每一个真实的现在，都是我们曾经幻想的未来！
May
12
我们知道在Linux中删除文件一般使用rm, 但是rm命令并不会真的清空保存该文件的数据块的内容，而只是释放了该文件所占用的索引节点和数据块。因此用rm删除的文件是可以通过一些方法恢复的(比如可以用debugfs恢复，具体方法Google之)。
有些时候我们要彻底删除一些文件，可以使用shred命令来实现，shred是coreutils的一部分，所以Linux中基本都会有这个命令。
shred彻底删除文件的方法:
$ shred -u file
shred会用一些随机内容覆盖文件所在的节点和数据块，并删除文件(-u参数)。
如果想清除的更彻底一点可以加-z 参数，意思是先用随机数据填充，最后再用0填充。
$ shred -u -z file
另外shred还可以清除整个分区或磁盘，比如想彻底清除/dev/sdb1分区的内容可以这样:
$ shred /dev/sdb1 (注意不要加-u参数)
shred的详细参数：
-f, --force 更改权限允许写入(如有必要)
-n, --iterations=N 重写N次，默认为3次
--random-source=FILE 从指定文件读取数据
-s, --size=N 将文件粉碎为固定大小 (可使用后缀如K、M、C等)
-u, --remove 重写后截短并移除文件
-v, --verbose 显示进度
-z, --zero - add 用0覆盖数据
–help 显示帮助
–version 显示版本信息
有些时候我们要彻底删除一些文件，可以使用shred命令来实现，shred是coreutils的一部分，所以Linux中基本都会有这个命令。
shred彻底删除文件的方法:
$ shred -u file
shred会用一些随机内容覆盖文件所在的节点和数据块，并删除文件(-u参数)。
如果想清除的更彻底一点可以加-z 参数，意思是先用随机数据填充，最后再用0填充。
$ shred -u -z file
另外shred还可以清除整个分区或磁盘，比如想彻底清除/dev/sdb1分区的内容可以这样:
$ shred /dev/sdb1 (注意不要加-u参数)
shred的详细参数：
-f, --force 更改权限允许写入(如有必要)
-n, --iterations=N 重写N次，默认为3次
--random-source=FILE 从指定文件读取数据
-s, --size=N 将文件粉碎为固定大小 (可使用后缀如K、M、C等)
-u, --remove 重写后截短并移除文件
-v, --verbose 显示进度
-z, --zero - add 用0覆盖数据
–help 显示帮助
–version 显示版本信息
May
5
在Windows中可以在某些路径中查找文件，也可以设定不在某些路径中查找文件，下面用Linux中的find的命令结合其-path -prune参数来看看在Linux中怎么实现此功能。
假如在当前目录下查找文件，且当前目录下有很多文件及目录（多层目录），包括dir0、dir1和dir2 ...等目录及dir00、dir01...dir10、dir11...等子目录。
1. 在当前目录下查找所有txt后缀文件
find ./ -name *.txt
2.在当前目录下的dir0目录及子目录下查找txt后缀文件
find ./ -path './dir0*' -name *.txt
3.在当前目录下的dir0目录下的子目录dir00及其子目录下查找txt后缀文件
find ./ -path '*dir00*' -name *.txt
4.在除dir0及子目录以外的目录下查找txt后缀文件
find ./ -path './dir0*' -a -prune -o -name *.txt -print
说明：-a 应该是and的缩写，意思是逻辑运算符‘或’(&&); -o应该是or的缩写,意思是逻辑运算符‘与’(||), -not 表示非.
命令行的意思是：如果目录dir0存在（即-a左边为真），则求-prune的值，-prune 返回真，‘与’逻辑表达式为真（即-path './dir0*' -a -prune 为真），find命令将在除这个目录以外的目录下查找txt后缀文件并打印出来；如果目录dir0不存在（即-a左边为假），则不求值-prune ，‘与’逻辑表达式为假，则在当前目录下查找所有txt后缀文件。
5.在除dir0、dir1及子目录以外的目录下查找txt后缀文件
find ./ \( -path './dir0*' -o -path './dir1*' \) -a -prune -o -name *.txt -print
注意：圆括号()表示表达式的结合。即指示 shell 不对后面的字符作特殊解释，而留给 find 命令去解释其意义。由于命令行不能直接使用圆括号，所以需要用反斜杠'\'进行转意(即'\'转意字符使命令行认识圆括号)。同时注意'\('，'\)'两边都需空格。
6.在dir0、dir1及子目录下查找txt后缀文件
find ./ \( -path './dir0*' -o -path './dir1*' \) -a -name *.txt -print
+1. 在所有以名为dir_general的目录下查找txt后缀文件
find ./ -path '*/dir_general/*' -name *.txt -print
注：本文参考了wolf的作品
假如在当前目录下查找文件，且当前目录下有很多文件及目录（多层目录），包括dir0、dir1和dir2 ...等目录及dir00、dir01...dir10、dir11...等子目录。
1. 在当前目录下查找所有txt后缀文件
find ./ -name *.txt
2.在当前目录下的dir0目录及子目录下查找txt后缀文件
find ./ -path './dir0*' -name *.txt
3.在当前目录下的dir0目录下的子目录dir00及其子目录下查找txt后缀文件
find ./ -path '*dir00*' -name *.txt
4.在除dir0及子目录以外的目录下查找txt后缀文件
find ./ -path './dir0*' -a -prune -o -name *.txt -print
说明：-a 应该是and的缩写，意思是逻辑运算符‘或’(&&); -o应该是or的缩写,意思是逻辑运算符‘与’(||), -not 表示非.
命令行的意思是：如果目录dir0存在（即-a左边为真），则求-prune的值，-prune 返回真，‘与’逻辑表达式为真（即-path './dir0*' -a -prune 为真），find命令将在除这个目录以外的目录下查找txt后缀文件并打印出来；如果目录dir0不存在（即-a左边为假），则不求值-prune ，‘与’逻辑表达式为假，则在当前目录下查找所有txt后缀文件。
5.在除dir0、dir1及子目录以外的目录下查找txt后缀文件
find ./ \( -path './dir0*' -o -path './dir1*' \) -a -prune -o -name *.txt -print
注意：圆括号()表示表达式的结合。即指示 shell 不对后面的字符作特殊解释，而留给 find 命令去解释其意义。由于命令行不能直接使用圆括号，所以需要用反斜杠'\'进行转意(即'\'转意字符使命令行认识圆括号)。同时注意'\('，'\)'两边都需空格。
6.在dir0、dir1及子目录下查找txt后缀文件
find ./ \( -path './dir0*' -o -path './dir1*' \) -a -name *.txt -print
+1. 在所有以名为dir_general的目录下查找txt后缀文件
find ./ -path '*/dir_general/*' -name *.txt -print
注：本文参考了wolf的作品
Apr
29
1.站点根目录下查找是否被放置webshell木马根据语句判断是不是PHP木马脚本
# find ./ -name “*.php” |xargs egrep “phpspy|c99sh|milw0rm|eval\(gunerpress|eval\(base64_decode|spider_bc”>/tmp/php.txt
# grep -r –include=*.php ‘[^a-z]eval_r($_POST’ > /tmp/eval.txt
#grep -r –include=*.php ‘file_put_contents(.*$_POST\[.*\]);’ > tmp/file_put_contents.txt
2.统计服务器访问日志中所有不同ip出现的次数
# cat access.log |awk ‘{print $4}’| sort | uniq -c |sort -rn
或者
#cat access.log | awk ‘{print $4}’ | sort -n | awk ‘{S[$NF]++} END {for(a in S) {print a”\t” S[a]}}’ | sort +1 -2nr
awk ‘{print $4}’ : 通过管道将第四个字段也就是ip地址筛选出来。
sort -n ：将ip地址进行排序
awk ‘{S[$NF]++} END{for(a in S) {print a”\t” S[a]}}：
$NF是awk里的一个变量，代表最后一个字段的内容，由于这晨只有一个字段，即：IP地址，所以$NF代表IP地址。
S[$NF]++里的S代表一个数组，然后统计IP地址出现的次数. 后面是一个for in 循环语句，将这个数组里的值和键打印出来。
sort +1 -2nr：以第二个字段，也就是每个IP的访问次数进行排序
3.分析出现次数最多的ip对网站的具体数据访问情况
# grep -e IP access.log > filename
# cat filename |awk ‘{print $8}’|sort|uniq -c|sort -rn
4.访问次数最多的文件或页面,取前20
# cat access.log|awk ‘{print $11}’|sort|uniq -c|sort -nr|head -20
5.列出传输最大的几个exe文件（分析下载站的时候常用）
# cat access.log |awk ‘($7~/\.exe/){print $10 ” ” $1 ” ” $4 ” ” $7}’|sort -nr|head -20
6.列出输出大于200000byte(约200kb)的exe文件以及对应文件发生次数
# cat access.log |awk ‘($10 > 200000 && $7~/\.exe/){print $7}’|sort -n|uniq -c|sort -nr|head -100
7.如果日志最后一列记录的是页面文件传输时间，则有列出到客户端最耗时的页面
# cat access.log |awk ‘($7~/\.php/){print $NF ” ” $1 ” ” $4 ” ” $7}’|sort -nr|head -100
8.列出最最耗时的页面(超过60秒的)的以及对应页面发生次数
# cat access.log |awk ‘($NF > 60 && $7~/\.php/){print $7}’|sort -n|uniq -c|sort -nr|head -100
9.列出传输时间超过 30 秒的文件
# cat access.log |awk ‘($NF > 30){print $7}’|sort -n|uniq -c|sort -nr|head -20
10.统计网站流量（G)
# cat access.log |awk ‘{sum+=$10} END {print sum/1024/1024/1024}’
11.统计404的连接
# awk ‘($9 ~/404/)’ access.log | awk ‘{print $9,$7}’ | sort
12. 统计http status.
# cat access.log |awk ‘{counts[$(9)]+=1}; END {for(code in counts) print code, counts[code]}'
# cat access.log |awk '{print $9}'|sort|uniq -c|sort -rn
13.查找挂马内容进行批量清除
# find /webbase/ -type f -exec grep 'www.800816.com.cn' -l {} \;
# sed -i "s/body{.*www.800816.com.cn.*}//g" `grep www.800816.com.cn -rl ./`
14.批量转换GBK为UTF-8文件编码
# find default -type d -exec mkdir -p utf/{} \;
# find default -type f -exec iconv -f GBK -t UTF-8 {} -o utf/{} \;
15.find查找文件的时候怎么避开多个文件目录
# find /usr/sam \(-path /usr/sam/dir1 -o -path /usr/sam/file1 \) -prune -o -name "*.txt" -print
16.查看tcp的并发请求数及其TCP连接状态：
# netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
# netstat -nat |awk '{print $6}'|sort|uniq -c|sort -rn
# netstat -n | awk '/^tcp/ {++state[$NF]}; END {for(key in state) print key,"\t",state[key]}'
# netstat -n | awk '/^tcp/ {++arr[$NF]};END {for(k in arr) print k,"\t",arr[k]}'
# netstat -n |awk '/^tcp/ {print $NF}'|sort|uniq -c|sort -rn
# netstat -ant | awk '{print $NF}' | grep -v '[a-z]' | sort | uniq -c
17.查找请求数前20的IP（常用于查找攻来源）
# netstat -anlp|grep 80|grep tcp|awk '{print $5}'|awk -F: '{print $1}'|sort|uniq -c|sort -nr|head -n20
# netstat -ant |awk '/:80/{split($5,ip,":");++A[ip[1]]}END{for(i in A) print A[i],i}' |sort -rn|head -n10
18.查看有多少个活动的php-cgi进程
# netstat -anp | grep php-cgi | grep ^tcp | wc -l
19.查找较多time_wait连接
# netstat -n|grep TIME_WAIT|awk '{print $5}'|sort|uniq -c|sort -rn|head -n20
20.找查较多的SYN连接
# netstat -an | grep SYN | awk '{print $5}' | awk -F: '{print $1}' | sort | uniq -c | sort -nr | more
21.根据端口列进程
# netstat -ntlp | grep 80 | awk '{print $7}' | cut -d/ -f1
22.抓包用来防止80端口被人攻击时可以分析数据
# tcpdump -c 10000 -i eth0 -n dst port 80 > /root/pkts
23.用tcpdump嗅探80端口的访问看看谁最高
# tcpdump -i eth0 -tnn dst port 80 -c 1000 | awk -F"." '{print $1"."$2"."$3"."$4}' | sort | uniq -c | sort -nr |head -20
24.查看是哪些蜘蛛在抓取内容。
# /usr/sbin/tcpdump -i eth0 -l -s 0 -w - dst port 80 | strings | grep -i user-agent | grep -i -E 'bot|crawler|slurp|spider'
25.按域统计流量
# zcat squid_access.log.tar.gz| awk '{print $10,$7}' |awk 'BEGIN{FS="[ /]"}{trfc[$4]+=$1}END{for(domain in trfc){printf "%s\t%d\n",domain,trfc[domain]}}'
26.查看数据库执行的sql
# /usr/sbin/tcpdump -i eth0 -s 0 -l -w - dst port 3306 | strings | egrep -i 'SELECT|UPDATE|DELETE|INSERT|SET|COMMIT|ROLLBACK|CREATE|DROP|ALTER|CALL'
27.将匹配Root一行中no替换成yes
# sed -i '/Root/s/no/yes/' /etc/ssh/sshd_config
28.去掉第一列
# awk '{for(i=2;i<=NF;i++) if(i!=NF){printf $i" "}else{print $i} }' list
29.按内存从大到小排列
# ps -e -o "%C : %p : %z : %a"|sort -k5 -nr
30.按cpu利用率从大到小排列
# ps -e -o "%C : %p : %z : %a"|sort -nr
31.怎样知道某个进程在哪个CPU上运行
# ps -eo pid,args,psr
32.清除僵死进程。
# ps -eal | awk '{ if ($2 == "Z") {print $4}}' | kill -9
33.查看硬件制造商
# dmidecode -s system-product-name
34.查找占用磁盘IO最多的进程
# wget -c http://linux.web.psi.ch/dist/scientific/5/gfa/all/dstat-0.6.7-1.rf.noarch.rpm
# dstat -M topio -d -M topbio
35.检查I/O使用率(%util)是否超过100%
# iostat -x 1 2
36.磁盘空间，检查是否有分区使用率(Use%)过高(比如超过90%) 如发现某个分区空间接近用尽，可以进入该分区的挂载点，用以下命令找出占用空间最多的文件或目录：
# df -h
# du -cks * | sort -rn | head -n 10
37.CPU负载检查前三个输出值是否超过了系统逻辑CPU的4倍。
# cat /proc/loadavg
38.CPU的数量
# cat /proc/cpuinfo |grep -c processor
39.检查网络流量(rxbyt/s, txbyt/s)是否过高
# sar -n DEV
40.每隔1秒显示一下网络流量
# watch -n 1 "/sbin/ifconfig eth0 | grep bytes"
41.批量覆盖目录下的文件不用确定是否执行
# \cp -rf /svn/wwwroot /wwwroot
42.调试命令
# strace -p pid
43.跟踪指定进程的PID
# gdb -p pid
44.查看当前进程打开了多少个文件句柄
lsof -n |awk ‘{print $2}’|sort|uniq -c |sort -nr|more
45.查找最近一天被修改的HTML文件
find -mtime -1 -type f -name \*.html
46.修改网站的权限
find -type f -name \*.php -exec chmod 444 {} \;
find ./ -type d -exec chmod 555{} \;
# find ./ -name “*.php” |xargs egrep “phpspy|c99sh|milw0rm|eval\(gunerpress|eval\(base64_decode|spider_bc”>/tmp/php.txt
# grep -r –include=*.php ‘[^a-z]eval_r($_POST’ > /tmp/eval.txt
#grep -r –include=*.php ‘file_put_contents(.*$_POST\[.*\]);’ > tmp/file_put_contents.txt
2.统计服务器访问日志中所有不同ip出现的次数
# cat access.log |awk ‘{print $4}’| sort | uniq -c |sort -rn
或者
#cat access.log | awk ‘{print $4}’ | sort -n | awk ‘{S[$NF]++} END {for(a in S) {print a”\t” S[a]}}’ | sort +1 -2nr
awk ‘{print $4}’ : 通过管道将第四个字段也就是ip地址筛选出来。
sort -n ：将ip地址进行排序
awk ‘{S[$NF]++} END{for(a in S) {print a”\t” S[a]}}：
$NF是awk里的一个变量，代表最后一个字段的内容，由于这晨只有一个字段，即：IP地址，所以$NF代表IP地址。
S[$NF]++里的S代表一个数组，然后统计IP地址出现的次数. 后面是一个for in 循环语句，将这个数组里的值和键打印出来。
sort +1 -2nr：以第二个字段，也就是每个IP的访问次数进行排序
3.分析出现次数最多的ip对网站的具体数据访问情况
# grep -e IP access.log > filename
# cat filename |awk ‘{print $8}’|sort|uniq -c|sort -rn
4.访问次数最多的文件或页面,取前20
# cat access.log|awk ‘{print $11}’|sort|uniq -c|sort -nr|head -20
5.列出传输最大的几个exe文件（分析下载站的时候常用）
# cat access.log |awk ‘($7~/\.exe/){print $10 ” ” $1 ” ” $4 ” ” $7}’|sort -nr|head -20
6.列出输出大于200000byte(约200kb)的exe文件以及对应文件发生次数
# cat access.log |awk ‘($10 > 200000 && $7~/\.exe/){print $7}’|sort -n|uniq -c|sort -nr|head -100
7.如果日志最后一列记录的是页面文件传输时间，则有列出到客户端最耗时的页面
# cat access.log |awk ‘($7~/\.php/){print $NF ” ” $1 ” ” $4 ” ” $7}’|sort -nr|head -100
8.列出最最耗时的页面(超过60秒的)的以及对应页面发生次数
# cat access.log |awk ‘($NF > 60 && $7~/\.php/){print $7}’|sort -n|uniq -c|sort -nr|head -100
9.列出传输时间超过 30 秒的文件
# cat access.log |awk ‘($NF > 30){print $7}’|sort -n|uniq -c|sort -nr|head -20
10.统计网站流量（G)
# cat access.log |awk ‘{sum+=$10} END {print sum/1024/1024/1024}’
11.统计404的连接
# awk ‘($9 ~/404/)’ access.log | awk ‘{print $9,$7}’ | sort
12. 统计http status.
# cat access.log |awk ‘{counts[$(9)]+=1}; END {for(code in counts) print code, counts[code]}'
# cat access.log |awk '{print $9}'|sort|uniq -c|sort -rn
13.查找挂马内容进行批量清除
# find /webbase/ -type f -exec grep 'www.800816.com.cn' -l {} \;
# sed -i "s/body{.*www.800816.com.cn.*}//g" `grep www.800816.com.cn -rl ./`
14.批量转换GBK为UTF-8文件编码
# find default -type d -exec mkdir -p utf/{} \;
# find default -type f -exec iconv -f GBK -t UTF-8 {} -o utf/{} \;
15.find查找文件的时候怎么避开多个文件目录
# find /usr/sam \(-path /usr/sam/dir1 -o -path /usr/sam/file1 \) -prune -o -name "*.txt" -print
16.查看tcp的并发请求数及其TCP连接状态：
# netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
# netstat -nat |awk '{print $6}'|sort|uniq -c|sort -rn
# netstat -n | awk '/^tcp/ {++state[$NF]}; END {for(key in state) print key,"\t",state[key]}'
# netstat -n | awk '/^tcp/ {++arr[$NF]};END {for(k in arr) print k,"\t",arr[k]}'
# netstat -n |awk '/^tcp/ {print $NF}'|sort|uniq -c|sort -rn
# netstat -ant | awk '{print $NF}' | grep -v '[a-z]' | sort | uniq -c
17.查找请求数前20的IP（常用于查找攻来源）
# netstat -anlp|grep 80|grep tcp|awk '{print $5}'|awk -F: '{print $1}'|sort|uniq -c|sort -nr|head -n20
# netstat -ant |awk '/:80/{split($5,ip,":");++A[ip[1]]}END{for(i in A) print A[i],i}' |sort -rn|head -n10
18.查看有多少个活动的php-cgi进程
# netstat -anp | grep php-cgi | grep ^tcp | wc -l
19.查找较多time_wait连接
# netstat -n|grep TIME_WAIT|awk '{print $5}'|sort|uniq -c|sort -rn|head -n20
20.找查较多的SYN连接
# netstat -an | grep SYN | awk '{print $5}' | awk -F: '{print $1}' | sort | uniq -c | sort -nr | more
21.根据端口列进程
# netstat -ntlp | grep 80 | awk '{print $7}' | cut -d/ -f1
22.抓包用来防止80端口被人攻击时可以分析数据
# tcpdump -c 10000 -i eth0 -n dst port 80 > /root/pkts
23.用tcpdump嗅探80端口的访问看看谁最高
# tcpdump -i eth0 -tnn dst port 80 -c 1000 | awk -F"." '{print $1"."$2"."$3"."$4}' | sort | uniq -c | sort -nr |head -20
24.查看是哪些蜘蛛在抓取内容。
# /usr/sbin/tcpdump -i eth0 -l -s 0 -w - dst port 80 | strings | grep -i user-agent | grep -i -E 'bot|crawler|slurp|spider'
25.按域统计流量
# zcat squid_access.log.tar.gz| awk '{print $10,$7}' |awk 'BEGIN{FS="[ /]"}{trfc[$4]+=$1}END{for(domain in trfc){printf "%s\t%d\n",domain,trfc[domain]}}'
26.查看数据库执行的sql
# /usr/sbin/tcpdump -i eth0 -s 0 -l -w - dst port 3306 | strings | egrep -i 'SELECT|UPDATE|DELETE|INSERT|SET|COMMIT|ROLLBACK|CREATE|DROP|ALTER|CALL'
27.将匹配Root一行中no替换成yes
# sed -i '/Root/s/no/yes/' /etc/ssh/sshd_config
28.去掉第一列
# awk '{for(i=2;i<=NF;i++) if(i!=NF){printf $i" "}else{print $i} }' list
29.按内存从大到小排列
# ps -e -o "%C : %p : %z : %a"|sort -k5 -nr
30.按cpu利用率从大到小排列
# ps -e -o "%C : %p : %z : %a"|sort -nr
31.怎样知道某个进程在哪个CPU上运行
# ps -eo pid,args,psr
32.清除僵死进程。
# ps -eal | awk '{ if ($2 == "Z") {print $4}}' | kill -9
33.查看硬件制造商
# dmidecode -s system-product-name
34.查找占用磁盘IO最多的进程
# wget -c http://linux.web.psi.ch/dist/scientific/5/gfa/all/dstat-0.6.7-1.rf.noarch.rpm
# dstat -M topio -d -M topbio
35.检查I/O使用率(%util)是否超过100%
# iostat -x 1 2
36.磁盘空间，检查是否有分区使用率(Use%)过高(比如超过90%) 如发现某个分区空间接近用尽，可以进入该分区的挂载点，用以下命令找出占用空间最多的文件或目录：
# df -h
# du -cks * | sort -rn | head -n 10
37.CPU负载检查前三个输出值是否超过了系统逻辑CPU的4倍。
# cat /proc/loadavg
38.CPU的数量
# cat /proc/cpuinfo |grep -c processor
39.检查网络流量(rxbyt/s, txbyt/s)是否过高
# sar -n DEV
40.每隔1秒显示一下网络流量
# watch -n 1 "/sbin/ifconfig eth0 | grep bytes"
41.批量覆盖目录下的文件不用确定是否执行
# \cp -rf /svn/wwwroot /wwwroot
42.调试命令
# strace -p pid
43.跟踪指定进程的PID
# gdb -p pid
44.查看当前进程打开了多少个文件句柄
lsof -n |awk ‘{print $2}’|sort|uniq -c |sort -nr|more
45.查找最近一天被修改的HTML文件
find -mtime -1 -type f -name \*.html
46.修改网站的权限
find -type f -name \*.php -exec chmod 444 {} \;
find ./ -type d -exec chmod 555{} \;
Apr
29
查找一句话PHP木马：
# find ./ -name "*.php" |xargs egrep "phpspy|c99sh|milw0rm|eval\(gunerpress|eval\(base64_decode|spider_bc"> /tmp/php.txt
# grep -r --include=*.php '[^a-z]eval($_POST' . > /tmp/eval.txt
# grep -r --include=*.php 'file_put_contents(.*$_POST\[.*\]);' . > /tmp/file_put_contents.txt
# find ./ -name "*.php" -type f -print0 | xargs -0 egrep "(phpspy|c99sh|milw0rm|eval\(gzuncompress\(base64_decode|eval\(base64_decode|spider_bc|gzinflate)" | awk -F: '{print $1}' | sort | uniq
查找最近一天被修改的PHP文件：
# find -mtime -1 -type f -name \*.php
修改网站的权限：
# find -type f -name \*.php -exec chmod 444 {} \;
# find ./ -type d -exec chmod 555{} \;
建议将php相关危险函数在php.ini里面禁用掉。
disable_functions = system,exec,shell_exec,passthru
# find ./ -name "*.php" |xargs egrep "phpspy|c99sh|milw0rm|eval\(gunerpress|eval\(base64_decode|spider_bc"> /tmp/php.txt
# grep -r --include=*.php '[^a-z]eval($_POST' . > /tmp/eval.txt
# grep -r --include=*.php 'file_put_contents(.*$_POST\[.*\]);' . > /tmp/file_put_contents.txt
# find ./ -name "*.php" -type f -print0 | xargs -0 egrep "(phpspy|c99sh|milw0rm|eval\(gzuncompress\(base64_decode|eval\(base64_decode|spider_bc|gzinflate)" | awk -F: '{print $1}' | sort | uniq
查找最近一天被修改的PHP文件：
# find -mtime -1 -type f -name \*.php
修改网站的权限：
# find -type f -name \*.php -exec chmod 444 {} \;
# find ./ -type d -exec chmod 555{} \;
建议将php相关危险函数在php.ini里面禁用掉。
disable_functions = system,exec,shell_exec,passthru
Mar
13
1、
mysqld --verbose --help
这个命令生成所有mysqld选项和可配置变量的列表
2、
通过连接它并执行这个命令，可以看到实际上使用的变量的值：
mysql> SHOW VARIABLES;
还可以通过下面的语句看到运行服务器的统计和状态指标：
mysql>SHOW STATUS；
使用mysqladmin还可以获得系统变量和状态信息：
shell> mysqladmin variables
shell> mysqladmin extended-status
shell> mysqladmin flush-table 命令可以立即关闭所有不使用的表并将所有使用中的表标记为已经关闭，这样可以有效释放大多数使用中的内存。FLUSH TABLE在关闭所有表之前不返回结果。
swap -s检查可用交换区
mysql内存计算公式
mysql used mem = key_buffer_size + query_cache_size + tmp_table_size
+ innodb_buffer_pool_size + innodb_additional_mem_pool_size
+ innodb_log_buffer_size
+ max_connections * (
read_buffer_size + read_rnd_buffer_size
+ sort_buffer_size+ join_buffer_size
+ binlog_cache_size + thread_stack
)
在mysql 中输入如下命令，可自动计算自己的当前配置最大的内存消耗
SHOW VARIABLES LIKE 'innodb_buffer_pool_size';
SHOW VARIABLES LIKE 'innodb_additional_mem_pool_size';
SHOW VARIABLES LIKE 'innodb_log_buffer_size';
SHOW VARIABLES LIKE 'thread_stack';
SET @kilo_bytes = 1024;
SET @mega_bytes = @kilo_bytes * 1024;
SET @giga_bytes = @mega_bytes * 1024;
SET @innodb_buffer_pool_size = 2 * @giga_bytes;
SET @innodb_additional_mem_pool_size = 16 * @mega_bytes;
SET @innodb_log_buffer_size = 8 * @mega_bytes;
SET @thread_stack = 192 * @kilo_bytes;
SELECT
( @@key_buffer_size + @@query_cache_size + @@tmp_table_size
+ @innodb_buffer_pool_size + @innodb_additional_mem_pool_size
+ @innodb_log_buffer_size
+ @@max_connections * (
@@read_buffer_size + @@read_rnd_buffer_size + @@sort_buffer_size
+ @@join_buffer_size + @@binlog_cache_size + @thread_stack
) ) / @giga_bytes AS MAX_MEMORY_GB;
mysql关键参数设置
Mysqld 数据库的参数设置有两种类型，
一种是全局参数，影响服务器的全局操作；
另一种是会话级参数，只影响当前的客户端连接的相关操作。
服务器启动时，所有全局参数都初始化为默认值。可以在初始化文件或命令行中指定的选项来更改这些默认值。服务器启动后，通过连接服务器并执行 SET GLOBAL var_name 语句可以更改动态全局参数。要想更改全局参数，必须具有 SUPER 权限。全局参数的修改只对新的连接生效，已有的客户端连接并不会生效。
服务器还可以为每个客户端连接维护会话级参数，客户端连接时使用相应全局参数的当前值对客户端会话参数进行初始化。客户可以通过 SET SESSION var_name 语句来更改动态会话参数。设置会话级参数不需要特殊权限，但每个客户端可以只更改自己的会话级参数，不能更改其它客户的会话级参数。
不指定设置的参数类型时，默认设置的是会话级参数。
(1)、max_connections：
允许的同时客户的数量。增加该值增加 mysqld 要求的文件描述符的数量。这个数字应该增加，否则，你将经常看到 too many connections 错误。 默认数值是100，我把它改为1024 。
(2)、record_buffer：
每个进行一个顺序扫描的线程为其扫描的每张表分配这个大小的一个缓冲区。如果你做很多顺序扫描，你可能想要增加该值。默认数值是131072(128k)，我把它改为16773120 (16m)
(3)、key_buffer_size：
为了最小化磁盘的 I/O ， MyISAM 存储引擎的表使用键高速缓存来缓存索引，这个键高速缓存的大小则通过 key-buffer-size 参数来设置。如果应用系统中使用的表以 MyISAM 存储引擎为主，则应该适当增加该参数的值，以便尽可能的缓存索引，提高访问的速度。
索引块是缓冲的并且被所有的线程共享。key_buffer_size是用于索引块的缓冲区大小，增加它可得到更好处理的索引(对所有读和多重写)，到你能负担得起那样多。如果你使它太大，系统将开始换页并且真的变慢了。默认数值是8388600(8m)，我的mysql主机有2gb内存，所以我把它改为 402649088(400mb)。
默认情况下，所有的索引都使用相同的键高速缓存，当访问的索引不在缓存中时，使用 LRU （ Least Recently Used 最近最少使用）算法来替换缓存中最近最少使用的索引块。为了进一步避免对键高速缓存的争用，从 MySQL5.1 开始，可以设置多个键高速缓存，并为不同的索引键指定使用的键高速缓存。下面的例子演示如何修改高速键缓存的值，如何设置多个键高速缓存，以及如何为不同的索引指定不同的缓存：
显示当前的参数大小，为16M：
mysql> show variables like 'key_buffer_size';
+-----------------+-------+
| Variable_name | Value |
+-----------------+-------+
| key_buffer_size | 16384 |
+-----------------+-------+
1 row in set (0.00 sec)
修改参数值到200M：
mysql> set global key_buffer_size=204800;
Query OK, 0 rows affected (0.00 sec)
mysql> show variables like 'key_buffer_size';
+-----------------+--------+
| Variable_name | Value |
+-----------------+--------+
| key_buffer_size | 204800 |
+-----------------+--------+
1 row in set (0.00 sec)
上面介绍的是默认的键缓存，下面介绍如何设置多个键缓存：
设置 hot_cache 的键缓存 100M ， cold_cache 的键缓存 100M ，另外还有 200M 的默认的键缓存。如果索引不指定键缓存，则会放在默认的键缓存中。
mysql> set global hot_cache.key_buffer_size=102400;
Query OK, 0 rows affected (0.00 sec)
mysql> set global cold_cache.key_buffer_size= 1024 00;
Query OK, 0 rows affected (0.01 sec)
mysql> show variables like 'key_buffer_size';
+-----------------+--------+
| Variable_name | Value |
+-----------------+--------+
| key_buffer_size | 204800 |
+-----------------+--------+
1 row in set (0.00 sec)
如果要显示设置的多键缓存的值，可以使用：
mysql> SELECT @@global.hot_cache.key_buffer_size;
+------------------------------------+
| @@global.hot_cache.key_buffer_size |
+------------------------------------+
| 102400 |
+------------------------------------+
1 row in set (0.03 sec)
mysql> SELECT @@global.cold_cache.key_buffer_size;
+-------------------------------------+
| @@global.cold_cache.key_buffer_size |
+-------------------------------------+
| 102400 |
+-------------------------------------+
1 row in set (0.00 sec)
指定不同的索引使用不同的键缓存：
mysql> CACHE INDEX test1 in hot_cache;
+------------+--------------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+------------+--------------------+----------+----------+
| test .test1 | assign_to_keycache | status | OK |
+------------+--------------------+----------+----------+
1 row in set (0.00 sec)
mysql> CACHE INDEX test2 in hot_cache;
+------------+--------------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+------------+--------------------+----------+----------+
| test .test2 | assign_to_keycache | status | OK |
+------------+--------------------+----------+----------+
1 row in set (0.00 sec)
通常在数据库刚刚启动的时候，需要等待数据库热起来，也就是等待数据被缓存到缓存区中，这段时间数据库会因为 buffer 的命中率低而导致应用的访问效率不高。使用键高速缓存的时候，可以通过命令将索引预加载到缓存区中，大大缩短了数据库预热的时间。具体的操作方式是：
mysql> LOAD INDEX INTO CACHE test1,test2 IGNORE LEAVES;
+------------+--------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+------------+--------------+----------+----------+
| test .test1 | preload_keys | status | OK |
| test .test2 | preload_keys | status | OK |
+------------+--------------+----------+----------+
2 rows in set (3.89 sec)
如果已经使用 CACHE INDEX 语句为索引分配了一个键高速缓冲，预加载可以将索引块放入该缓存，否则，索引块将被加载到默认的键高速缓冲。
4)、back_log：
要求 mysql 能有的连接数量。当主要mysql线程在一个很短时间内得到非常多的连接请求，这就起作用，然后主线程花些时间(尽管很短)检查连接并且启动一个新线程。
back_log 值指出在mysql暂时停止回答新请求之前的短时间内多少个请求可以被存在堆栈中。只有如果期望在一个短时间内有很多连接，你需要增加它，换句话说，这值对到来的tcp/ip连接的侦听队列的大小。你的操作系统在这个队列大小上有它自己的限制。试图设定back_log高于你的操作系统的限制将是无效的。
当你观察你的主机进程列表，发现大量 264084 | unauthenticated user | xxx.xxx.xxx.xxx | null | connect | null | login | null 的待连接进程时，就要加大 back_log 的值了。默认数值是50，我把它改为500。
(5)、interactive_timeout：
服务器在关闭它前在一个交互连接上等待行动的秒数。一个交互的客户被定义为对 mysql_real_connect()使用 client_interactive 选项的客户。 默认数值是28800，我把它改为7200。
(6)、sort_buffer：
每个需要进行排序的线程分配该大小的一个缓冲区。增加这值加速order by或group by操作。默认数值是2097144(2m)，我把它改为 16777208 (16m)。
(7)、table_cache：
为所有线程打开表的数量。增加该值能增加mysqld要求的文件描述符的数量。mysql对每个唯一打开的表需要2个文件描述符。默认数值是64，我把它改为512。
(8)、thread_cache_size：
可以复用的保存在中的线程的数量。如果有，新的线程从缓存中取得，当断开连接的时候如果有空间，客户的线置在缓存中。如果有很多新的线程，为了提高性能可以这个变量值。通过比较 connections 和 threads_created 状态的变量，可以看到这个变量的作用。我把它设置为 80。
(9)mysql的搜索功能
用mysql进行搜索，目的是能不分大小写，又能用中文进行搜索
只需起动mysqld时指定 --default-character-set=gb2312
(10)、wait_timeout：
服务器在关闭它之前在一个连接上等待行动的秒数。 默认数值是28800，我把它改为7200。
(11)、innodb_thread_concurrency：
你的服务器CPU有几个就设置为几,默认为8。
(12)、query_cache_size 与 query_cache_limit
QueryCache 之后所带来的负面影响：
a) Query 语句的hash 运算以及hash 查找资源消耗。当我们使用Query Cache 之后，每条SELECT
类型的Query 在到达MySQL 之后，都需要进行一个hash 运算然后查找是否存在该Query 的
Cache，虽然这个hash 运算的算法可能已经非常高效了，hash 查找的过程也已经足够的优化
了，对于一条Query 来说消耗的资源确实是非常非常的少，但是当我们每秒都有上千甚至几千
条Query 的时候，我们就不能对产生的CPU 的消耗完全忽视了。
b) Query Cache 的失效问题。如果我们的表变更比较频繁，则会造成Query Cache 的失效率非常
高。这里的表变更不仅仅指表中数据的变更，还包括结构或者索引等的任何变更。也就是说我
们每次缓存到Query Cache 中的Cache 数据可能在刚存入后很快就会因为表中的数据被改变而被
清除，然后新的相同Query 进来之后无法使用到之前的Cache。
c) Query Cache 中缓存的是Result Set ，而不是数据页，也就是说，存在同一条记录被Cache 多
次的可能性存在。从而造成内存资源的过渡消耗。当然，可能有人会说我们可以限定Query
Cache 的大小啊。是的，我们确实可以限定Query Cache 的大小，但是这样，Query Cache 就很
容易造成因为内存不足而被换出，造成命中率的下降。
QueryCache 的正确使用：
虽然Query Cache 的使用会存在一些负面影响，但是我们也应该相信其存在是必定有一定价值。我
们完全不用因为Query Cache 的上面三个负面影响就完全失去对Query Cache 的信心。只要我们理解了
Query Cache 的实现原理，那么我们就完全可以通过一定的手段在使用Query Cache 的时候扬长避短，重
发发挥其优势，并有效的避开其劣势。
首先，我们需要根据Query Cache 失效机制来判断哪些表适合使用Query 哪些表不适合。由于Query
Cache 的失效主要是因为Query 所依赖的Table 的数据发生了变化，造成Query 的Result Set 可能已经
有所改变而造成相关的Query Cache 全部失效，那么我们就应该避免在查询变化频繁的Table 的Query 上
使用，而应该在那些查询变化频率较小的Table 的Query 上面使用。MySQL 中针对Query Cache 有两个专
用的SQL Hint（提示）：SQL_NO_CACHE 和SQL_CACHE，分别代表强制不使用Query Cache 和强制使用
Query Cache。我们完全可以利用这两个SQL Hint，让MySQL 知道我们希望哪些SQL 使用Query Cache 而
哪些SQL 就不要使用了。这样不仅可以让变化频繁Table 的Query 浪费Query Cache 的内存，同时还可以
减少Query Cache 的检测量。
其次，对于那些变化非常小，大部分时候都是静态的数据，我们可以添加SQL_CACHE 的SQL Hint，
强制MySQL 使用Query Cache，从而提高该表的查询性能。
最后，有些SQL 的Result Set 很大，如果使用Query Cache 很容易造成Cache 内存的不足，或者将
之前一些老的Cache 冲刷出去。对于这一类Query 我们有两种方法可以解决，一是使用SQL_NO_CACHE 参
数来强制他不使用Query Cache 而每次都直接从实际数据中去查找， 另一种方法是通过设定
“query_cache_limit”参数值来控制Query Cache 中所Cache 的最大Result Set ，系统默认为
1M（1048576）。当某个Query 的Result Set 大于“query_cache_limit”所设定的值的时候，Query
Cache 是不会Cache 这个Query 的。
(13)、innodb_buffer_pool_size
innodb_buffer_pool_size 定义了 InnoDB 存储引擎的表数据和索引数据的最大内存缓冲区大小。和 MyISAM 存储引擎不同， MyISAM 的 key_buffer_size 只能缓存索引键，而 innodb_buffer_pool_size 却可以缓存数据块和索引键。适当的增加这个参数的大小，可以有效的减少 InnoDB 类型的表的磁盘 I/O 。在一个以 InnoDB 为主的专用数据库服务器上，可以考虑把该参数设置为物理内存大小的 60%-80%
InnoDB占用的内存，除innodb_buffer_pool_size用于存储页面缓存数据外，另外正常情况下还有大约8%的开销，主要用在每个缓存页帧的描述、adaptive hash等数据结构，如果不是安全关闭，启动时还要恢复的话，还要另开大约12%的内存用于恢复，两者相加就有差不多21%的开销。
这样，12G的innodb_buffer_pool_size，最多的时候InnoDB就可能占用到14.5G(12G X 21%)的内存，再加上操作系统用的几百M，近千个线程堆栈，就差不多16G了。
MAX_QUERIES_PER_HOUR 用来限制用户每小时运行的查询数量：
mysql> grant all on dbname。* to db@localhost identified by “123456” with max_connections_per_hour 5;
（db用户在dbname的数据库上控制用户每小时打开新连接的数量为5个）
MAX_USER_CONNECTIONS 限制有多少用户连接MYSQL服务器：
mysql> grant all on dbname。* to db@localhost identified by “123456” with max_user_connections 2;
（db用户在dbname的数据库账户一次可以同时连接的最大连接数为2个）
MAX_UPDATES_PER_HOUR 用来限制用户每小时的修改数据库数据的数量：
mysql> grant all on dbname。* to db@localhost identified by “123456” with max_updates_per_hour 5;
（db用户在dbname的数据库上控制用户每小时修改更新数据库的次数为5次）
MAX_USER_CONNECTIONS 用来限制用户每小时的修改数据库数据的数量：
mysql> grant all on dbname。* to db@localhost identified by “123456”
With MAX_QUERIES_PER_HOUR 20 ;指mysql单个用户的最大连接数
（db用户在dbname的数据库上控制用户每小时的连接数为20个）
调优举例
针对my.cnf文件进行优化：
[mysqld]
skip-locking（取消文件系统的外部锁）
skip-name-resolve（不进行域名反解析,注意由此带来的权限/授权问题）
key_buffer_size = 256M（分配给MyISAM索引缓存的内存总数）对于内存在4GB左右的服务器该参数可设置为256M或384M。
注意：该参数值设置的过大反而会是服务器整体效率降低！
max_allowed_packet = 4M（允许最大的包大小）
thread_stack = 256K（每个线程的大小）
table_cache = 128K（缓存可重用的线程数）
back_log = 384（临时停止响应新请求前在短时间内可以堆起多少请求，如果你需要在短时间内允许大量连接，可以增加该数值）
sort_buffer_size = 2M(分配给每个线程中处理排序)
read_buffer_size = 2M（读取的索引缓冲区大小）
join_buffer_size = 2M（分配给每个线程中处理扫描表连接及索引的内存）
myisam_sort_buffer_size = 64M（myisam引擎排序缓冲区的大小）
table_cache = 512（缓存数据表的数量，避免重复打开表的开销）
thread_cache_size = 64（缓存可重用线程数，见笑创建新线程的开销）
query_cache_size = 64M（控制分配给查询缓存的内存总量）
tmp_table_size = 256M(指定mysql缓存的内存大小)
max_connections = 768（最大连接数）指mysql整个的最大连接数
max_connect_errors = 10000(最大连接错误数据)
wait_timeout = 10（超时时间，可以避免攻击）
thread_concurrency = 8（根据cpu数量来设置）
skip-bdb 禁用不必要的引擎
skip-networking（关闭mysql tcp/ip连接方式）
Log-slow-queries = /var/log/mysqlslowqueries.log
long_query_time = 4（设定慢查询的时间）
skip-host-cache(提高mysql速度的)
open_files_limit = 4096(打开文件数）
interactive_timeout = 10(服务器在关闭它前在一个交互连接上等待行动的秒数)
max_user_connections = 500（最大用户连接数）
key_buffer_size 默认为218 调到128最佳
query_cache_size
tmp_table_size 默认为16M 调到64-256最挂
innodb_thread_concurrency=8 你的服务器CPU有几个就设置为几,默认为8
table_cache=1024 物理内存越大,设置就越大.默认为2402,调到512-1024最佳
innodb_additional_mem_pool_size=8M 默认为2M
innodb_flush_log_at_trx_commit=0 等到innodb_log_buffer_size列队满后再统一储存,默认为1
innodb_log_buffer_size=4M 默认为1M
read_buffer_size=4M 默认为64K
read_rnd_buffer_size 随机读 缓存区 默认为256K
sort_buffer_size=32M 默认为256K
max_connections=1024 默认为1210
thread_cache_size=120 默认为60
性能测试
1、mysql 自带测试工具
shell> perl -MCPAN -e shell
cpan> install DBI
cpan> install DBD::mysql
shell> cd sql-bench
shell> perl run-all-tests --server=server_name
server_name是一个支持的服务器。要获得所有选项和支持的服务器，调用命令：
shell> perl run-all-tests --help
2、mysqlreport
http://hackmysql.com/mysqlreport
参考文档：
http://dev.mysql.com/doc/refman/5.1/zh/optimization.html
http://hackmysql.com/tools
http://www.imysql.cn/
mysqld --verbose --help
这个命令生成所有mysqld选项和可配置变量的列表
2、
通过连接它并执行这个命令，可以看到实际上使用的变量的值：
mysql> SHOW VARIABLES;
还可以通过下面的语句看到运行服务器的统计和状态指标：
mysql>SHOW STATUS；
使用mysqladmin还可以获得系统变量和状态信息：
shell> mysqladmin variables
shell> mysqladmin extended-status
shell> mysqladmin flush-table 命令可以立即关闭所有不使用的表并将所有使用中的表标记为已经关闭，这样可以有效释放大多数使用中的内存。FLUSH TABLE在关闭所有表之前不返回结果。
swap -s检查可用交换区
mysql内存计算公式
mysql used mem = key_buffer_size + query_cache_size + tmp_table_size
+ innodb_buffer_pool_size + innodb_additional_mem_pool_size
+ innodb_log_buffer_size
+ max_connections * (
read_buffer_size + read_rnd_buffer_size
+ sort_buffer_size+ join_buffer_size
+ binlog_cache_size + thread_stack
)
在mysql 中输入如下命令，可自动计算自己的当前配置最大的内存消耗
SHOW VARIABLES LIKE 'innodb_buffer_pool_size';
SHOW VARIABLES LIKE 'innodb_additional_mem_pool_size';
SHOW VARIABLES LIKE 'innodb_log_buffer_size';
SHOW VARIABLES LIKE 'thread_stack';
SET @kilo_bytes = 1024;
SET @mega_bytes = @kilo_bytes * 1024;
SET @giga_bytes = @mega_bytes * 1024;
SET @innodb_buffer_pool_size = 2 * @giga_bytes;
SET @innodb_additional_mem_pool_size = 16 * @mega_bytes;
SET @innodb_log_buffer_size = 8 * @mega_bytes;
SET @thread_stack = 192 * @kilo_bytes;
SELECT
( @@key_buffer_size + @@query_cache_size + @@tmp_table_size
+ @innodb_buffer_pool_size + @innodb_additional_mem_pool_size
+ @innodb_log_buffer_size
+ @@max_connections * (
@@read_buffer_size + @@read_rnd_buffer_size + @@sort_buffer_size
+ @@join_buffer_size + @@binlog_cache_size + @thread_stack
) ) / @giga_bytes AS MAX_MEMORY_GB;
mysql关键参数设置
Mysqld 数据库的参数设置有两种类型，
一种是全局参数，影响服务器的全局操作；
另一种是会话级参数，只影响当前的客户端连接的相关操作。
服务器启动时，所有全局参数都初始化为默认值。可以在初始化文件或命令行中指定的选项来更改这些默认值。服务器启动后，通过连接服务器并执行 SET GLOBAL var_name 语句可以更改动态全局参数。要想更改全局参数，必须具有 SUPER 权限。全局参数的修改只对新的连接生效，已有的客户端连接并不会生效。
服务器还可以为每个客户端连接维护会话级参数，客户端连接时使用相应全局参数的当前值对客户端会话参数进行初始化。客户可以通过 SET SESSION var_name 语句来更改动态会话参数。设置会话级参数不需要特殊权限，但每个客户端可以只更改自己的会话级参数，不能更改其它客户的会话级参数。
不指定设置的参数类型时，默认设置的是会话级参数。
(1)、max_connections：
允许的同时客户的数量。增加该值增加 mysqld 要求的文件描述符的数量。这个数字应该增加，否则，你将经常看到 too many connections 错误。 默认数值是100，我把它改为1024 。
(2)、record_buffer：
每个进行一个顺序扫描的线程为其扫描的每张表分配这个大小的一个缓冲区。如果你做很多顺序扫描，你可能想要增加该值。默认数值是131072(128k)，我把它改为16773120 (16m)
(3)、key_buffer_size：
为了最小化磁盘的 I/O ， MyISAM 存储引擎的表使用键高速缓存来缓存索引，这个键高速缓存的大小则通过 key-buffer-size 参数来设置。如果应用系统中使用的表以 MyISAM 存储引擎为主，则应该适当增加该参数的值，以便尽可能的缓存索引，提高访问的速度。
索引块是缓冲的并且被所有的线程共享。key_buffer_size是用于索引块的缓冲区大小，增加它可得到更好处理的索引(对所有读和多重写)，到你能负担得起那样多。如果你使它太大，系统将开始换页并且真的变慢了。默认数值是8388600(8m)，我的mysql主机有2gb内存，所以我把它改为 402649088(400mb)。
默认情况下，所有的索引都使用相同的键高速缓存，当访问的索引不在缓存中时，使用 LRU （ Least Recently Used 最近最少使用）算法来替换缓存中最近最少使用的索引块。为了进一步避免对键高速缓存的争用，从 MySQL5.1 开始，可以设置多个键高速缓存，并为不同的索引键指定使用的键高速缓存。下面的例子演示如何修改高速键缓存的值，如何设置多个键高速缓存，以及如何为不同的索引指定不同的缓存：
显示当前的参数大小，为16M：
mysql> show variables like 'key_buffer_size';
+-----------------+-------+
| Variable_name | Value |
+-----------------+-------+
| key_buffer_size | 16384 |
+-----------------+-------+
1 row in set (0.00 sec)
修改参数值到200M：
mysql> set global key_buffer_size=204800;
Query OK, 0 rows affected (0.00 sec)
mysql> show variables like 'key_buffer_size';
+-----------------+--------+
| Variable_name | Value |
+-----------------+--------+
| key_buffer_size | 204800 |
+-----------------+--------+
1 row in set (0.00 sec)
上面介绍的是默认的键缓存，下面介绍如何设置多个键缓存：
设置 hot_cache 的键缓存 100M ， cold_cache 的键缓存 100M ，另外还有 200M 的默认的键缓存。如果索引不指定键缓存，则会放在默认的键缓存中。
mysql> set global hot_cache.key_buffer_size=102400;
Query OK, 0 rows affected (0.00 sec)
mysql> set global cold_cache.key_buffer_size= 1024 00;
Query OK, 0 rows affected (0.01 sec)
mysql> show variables like 'key_buffer_size';
+-----------------+--------+
| Variable_name | Value |
+-----------------+--------+
| key_buffer_size | 204800 |
+-----------------+--------+
1 row in set (0.00 sec)
如果要显示设置的多键缓存的值，可以使用：
mysql> SELECT @@global.hot_cache.key_buffer_size;
+------------------------------------+
| @@global.hot_cache.key_buffer_size |
+------------------------------------+
| 102400 |
+------------------------------------+
1 row in set (0.03 sec)
mysql> SELECT @@global.cold_cache.key_buffer_size;
+-------------------------------------+
| @@global.cold_cache.key_buffer_size |
+-------------------------------------+
| 102400 |
+-------------------------------------+
1 row in set (0.00 sec)
指定不同的索引使用不同的键缓存：
mysql> CACHE INDEX test1 in hot_cache;
+------------+--------------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+------------+--------------------+----------+----------+
| test .test1 | assign_to_keycache | status | OK |
+------------+--------------------+----------+----------+
1 row in set (0.00 sec)
mysql> CACHE INDEX test2 in hot_cache;
+------------+--------------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+------------+--------------------+----------+----------+
| test .test2 | assign_to_keycache | status | OK |
+------------+--------------------+----------+----------+
1 row in set (0.00 sec)
通常在数据库刚刚启动的时候，需要等待数据库热起来，也就是等待数据被缓存到缓存区中，这段时间数据库会因为 buffer 的命中率低而导致应用的访问效率不高。使用键高速缓存的时候，可以通过命令将索引预加载到缓存区中，大大缩短了数据库预热的时间。具体的操作方式是：
mysql> LOAD INDEX INTO CACHE test1,test2 IGNORE LEAVES;
+------------+--------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+------------+--------------+----------+----------+
| test .test1 | preload_keys | status | OK |
| test .test2 | preload_keys | status | OK |
+------------+--------------+----------+----------+
2 rows in set (3.89 sec)
如果已经使用 CACHE INDEX 语句为索引分配了一个键高速缓冲，预加载可以将索引块放入该缓存，否则，索引块将被加载到默认的键高速缓冲。
4)、back_log：
要求 mysql 能有的连接数量。当主要mysql线程在一个很短时间内得到非常多的连接请求，这就起作用，然后主线程花些时间(尽管很短)检查连接并且启动一个新线程。
back_log 值指出在mysql暂时停止回答新请求之前的短时间内多少个请求可以被存在堆栈中。只有如果期望在一个短时间内有很多连接，你需要增加它，换句话说，这值对到来的tcp/ip连接的侦听队列的大小。你的操作系统在这个队列大小上有它自己的限制。试图设定back_log高于你的操作系统的限制将是无效的。
当你观察你的主机进程列表，发现大量 264084 | unauthenticated user | xxx.xxx.xxx.xxx | null | connect | null | login | null 的待连接进程时，就要加大 back_log 的值了。默认数值是50，我把它改为500。
(5)、interactive_timeout：
服务器在关闭它前在一个交互连接上等待行动的秒数。一个交互的客户被定义为对 mysql_real_connect()使用 client_interactive 选项的客户。 默认数值是28800，我把它改为7200。
(6)、sort_buffer：
每个需要进行排序的线程分配该大小的一个缓冲区。增加这值加速order by或group by操作。默认数值是2097144(2m)，我把它改为 16777208 (16m)。
(7)、table_cache：
为所有线程打开表的数量。增加该值能增加mysqld要求的文件描述符的数量。mysql对每个唯一打开的表需要2个文件描述符。默认数值是64，我把它改为512。
(8)、thread_cache_size：
可以复用的保存在中的线程的数量。如果有，新的线程从缓存中取得，当断开连接的时候如果有空间，客户的线置在缓存中。如果有很多新的线程，为了提高性能可以这个变量值。通过比较 connections 和 threads_created 状态的变量，可以看到这个变量的作用。我把它设置为 80。
(9)mysql的搜索功能
用mysql进行搜索，目的是能不分大小写，又能用中文进行搜索
只需起动mysqld时指定 --default-character-set=gb2312
(10)、wait_timeout：
服务器在关闭它之前在一个连接上等待行动的秒数。 默认数值是28800，我把它改为7200。
(11)、innodb_thread_concurrency：
你的服务器CPU有几个就设置为几,默认为8。
(12)、query_cache_size 与 query_cache_limit
QueryCache 之后所带来的负面影响：
a) Query 语句的hash 运算以及hash 查找资源消耗。当我们使用Query Cache 之后，每条SELECT
类型的Query 在到达MySQL 之后，都需要进行一个hash 运算然后查找是否存在该Query 的
Cache，虽然这个hash 运算的算法可能已经非常高效了，hash 查找的过程也已经足够的优化
了，对于一条Query 来说消耗的资源确实是非常非常的少，但是当我们每秒都有上千甚至几千
条Query 的时候，我们就不能对产生的CPU 的消耗完全忽视了。
b) Query Cache 的失效问题。如果我们的表变更比较频繁，则会造成Query Cache 的失效率非常
高。这里的表变更不仅仅指表中数据的变更，还包括结构或者索引等的任何变更。也就是说我
们每次缓存到Query Cache 中的Cache 数据可能在刚存入后很快就会因为表中的数据被改变而被
清除，然后新的相同Query 进来之后无法使用到之前的Cache。
c) Query Cache 中缓存的是Result Set ，而不是数据页，也就是说，存在同一条记录被Cache 多
次的可能性存在。从而造成内存资源的过渡消耗。当然，可能有人会说我们可以限定Query
Cache 的大小啊。是的，我们确实可以限定Query Cache 的大小，但是这样，Query Cache 就很
容易造成因为内存不足而被换出，造成命中率的下降。
QueryCache 的正确使用：
虽然Query Cache 的使用会存在一些负面影响，但是我们也应该相信其存在是必定有一定价值。我
们完全不用因为Query Cache 的上面三个负面影响就完全失去对Query Cache 的信心。只要我们理解了
Query Cache 的实现原理，那么我们就完全可以通过一定的手段在使用Query Cache 的时候扬长避短，重
发发挥其优势，并有效的避开其劣势。
首先，我们需要根据Query Cache 失效机制来判断哪些表适合使用Query 哪些表不适合。由于Query
Cache 的失效主要是因为Query 所依赖的Table 的数据发生了变化，造成Query 的Result Set 可能已经
有所改变而造成相关的Query Cache 全部失效，那么我们就应该避免在查询变化频繁的Table 的Query 上
使用，而应该在那些查询变化频率较小的Table 的Query 上面使用。MySQL 中针对Query Cache 有两个专
用的SQL Hint（提示）：SQL_NO_CACHE 和SQL_CACHE，分别代表强制不使用Query Cache 和强制使用
Query Cache。我们完全可以利用这两个SQL Hint，让MySQL 知道我们希望哪些SQL 使用Query Cache 而
哪些SQL 就不要使用了。这样不仅可以让变化频繁Table 的Query 浪费Query Cache 的内存，同时还可以
减少Query Cache 的检测量。
其次，对于那些变化非常小，大部分时候都是静态的数据，我们可以添加SQL_CACHE 的SQL Hint，
强制MySQL 使用Query Cache，从而提高该表的查询性能。
最后，有些SQL 的Result Set 很大，如果使用Query Cache 很容易造成Cache 内存的不足，或者将
之前一些老的Cache 冲刷出去。对于这一类Query 我们有两种方法可以解决，一是使用SQL_NO_CACHE 参
数来强制他不使用Query Cache 而每次都直接从实际数据中去查找， 另一种方法是通过设定
“query_cache_limit”参数值来控制Query Cache 中所Cache 的最大Result Set ，系统默认为
1M（1048576）。当某个Query 的Result Set 大于“query_cache_limit”所设定的值的时候，Query
Cache 是不会Cache 这个Query 的。
(13)、innodb_buffer_pool_size
innodb_buffer_pool_size 定义了 InnoDB 存储引擎的表数据和索引数据的最大内存缓冲区大小。和 MyISAM 存储引擎不同， MyISAM 的 key_buffer_size 只能缓存索引键，而 innodb_buffer_pool_size 却可以缓存数据块和索引键。适当的增加这个参数的大小，可以有效的减少 InnoDB 类型的表的磁盘 I/O 。在一个以 InnoDB 为主的专用数据库服务器上，可以考虑把该参数设置为物理内存大小的 60%-80%
InnoDB占用的内存，除innodb_buffer_pool_size用于存储页面缓存数据外，另外正常情况下还有大约8%的开销，主要用在每个缓存页帧的描述、adaptive hash等数据结构，如果不是安全关闭，启动时还要恢复的话，还要另开大约12%的内存用于恢复，两者相加就有差不多21%的开销。
这样，12G的innodb_buffer_pool_size，最多的时候InnoDB就可能占用到14.5G(12G X 21%)的内存，再加上操作系统用的几百M，近千个线程堆栈，就差不多16G了。
MAX_QUERIES_PER_HOUR 用来限制用户每小时运行的查询数量：
mysql> grant all on dbname。* to db@localhost identified by “123456” with max_connections_per_hour 5;
（db用户在dbname的数据库上控制用户每小时打开新连接的数量为5个）
MAX_USER_CONNECTIONS 限制有多少用户连接MYSQL服务器：
mysql> grant all on dbname。* to db@localhost identified by “123456” with max_user_connections 2;
（db用户在dbname的数据库账户一次可以同时连接的最大连接数为2个）
MAX_UPDATES_PER_HOUR 用来限制用户每小时的修改数据库数据的数量：
mysql> grant all on dbname。* to db@localhost identified by “123456” with max_updates_per_hour 5;
（db用户在dbname的数据库上控制用户每小时修改更新数据库的次数为5次）
MAX_USER_CONNECTIONS 用来限制用户每小时的修改数据库数据的数量：
mysql> grant all on dbname。* to db@localhost identified by “123456”
With MAX_QUERIES_PER_HOUR 20 ;指mysql单个用户的最大连接数
（db用户在dbname的数据库上控制用户每小时的连接数为20个）
调优举例
针对my.cnf文件进行优化：
[mysqld]
skip-locking（取消文件系统的外部锁）
skip-name-resolve（不进行域名反解析,注意由此带来的权限/授权问题）
key_buffer_size = 256M（分配给MyISAM索引缓存的内存总数）对于内存在4GB左右的服务器该参数可设置为256M或384M。
注意：该参数值设置的过大反而会是服务器整体效率降低！
max_allowed_packet = 4M（允许最大的包大小）
thread_stack = 256K（每个线程的大小）
table_cache = 128K（缓存可重用的线程数）
back_log = 384（临时停止响应新请求前在短时间内可以堆起多少请求，如果你需要在短时间内允许大量连接，可以增加该数值）
sort_buffer_size = 2M(分配给每个线程中处理排序)
read_buffer_size = 2M（读取的索引缓冲区大小）
join_buffer_size = 2M（分配给每个线程中处理扫描表连接及索引的内存）
myisam_sort_buffer_size = 64M（myisam引擎排序缓冲区的大小）
table_cache = 512（缓存数据表的数量，避免重复打开表的开销）
thread_cache_size = 64（缓存可重用线程数，见笑创建新线程的开销）
query_cache_size = 64M（控制分配给查询缓存的内存总量）
tmp_table_size = 256M(指定mysql缓存的内存大小)
max_connections = 768（最大连接数）指mysql整个的最大连接数
max_connect_errors = 10000(最大连接错误数据)
wait_timeout = 10（超时时间，可以避免攻击）
thread_concurrency = 8（根据cpu数量来设置）
skip-bdb 禁用不必要的引擎
skip-networking（关闭mysql tcp/ip连接方式）
Log-slow-queries = /var/log/mysqlslowqueries.log
long_query_time = 4（设定慢查询的时间）
skip-host-cache(提高mysql速度的)
open_files_limit = 4096(打开文件数）
interactive_timeout = 10(服务器在关闭它前在一个交互连接上等待行动的秒数)
max_user_connections = 500（最大用户连接数）
key_buffer_size 默认为218 调到128最佳
query_cache_size
tmp_table_size 默认为16M 调到64-256最挂
innodb_thread_concurrency=8 你的服务器CPU有几个就设置为几,默认为8
table_cache=1024 物理内存越大,设置就越大.默认为2402,调到512-1024最佳
innodb_additional_mem_pool_size=8M 默认为2M
innodb_flush_log_at_trx_commit=0 等到innodb_log_buffer_size列队满后再统一储存,默认为1
innodb_log_buffer_size=4M 默认为1M
read_buffer_size=4M 默认为64K
read_rnd_buffer_size 随机读 缓存区 默认为256K
sort_buffer_size=32M 默认为256K
max_connections=1024 默认为1210
thread_cache_size=120 默认为60
性能测试
1、mysql 自带测试工具
shell> perl -MCPAN -e shell
cpan> install DBI
cpan> install DBD::mysql
shell> cd sql-bench
shell> perl run-all-tests --server=server_name
server_name是一个支持的服务器。要获得所有选项和支持的服务器，调用命令：
shell> perl run-all-tests --help
2、mysqlreport
http://hackmysql.com/mysqlreport
参考文档：
http://dev.mysql.com/doc/refman/5.1/zh/optimization.html
http://hackmysql.com/tools
http://www.imysql.cn/
