10月 16

用Nginx为uwsgi后端图片服务器做缓存服务

  很早处理的问题,现在拿出来做个记录。
  需求:后端图片服务处理各种格式、尺寸的图片。使用python处理,系统为Django+uwsgi(其实直接用tornado更好,也更方便)。前端需要做缓存,直接使用nginx。当前问题nginx和uwsgi连接后就不能使用cache服务了,nginx的proxy cache服务是在upstream的流转发过程中实现。所以要做个内部转发。nginx部分配置如下:

日志部分,添加缓存记录方将来统计击中率,参数为upstream_cache_status。
日志的中表示说明
MISS 未命中,请求被传送到后端
HIT 缓存命中
EXPIRED 缓存已经过期请求被传送到后端
UPDATING 正在更新缓存,将使用旧的应答
STALE 后端将得到过期的应答

log_format main ‘$remote_addr – $remote_user [$time_local] “$request” ‘
‘$status $body_bytes_sent “$http_referer” ‘
‘”$http_user_agent” “$http_x_forwarded_for” “$request_time” ‘
‘”$upstream_cache_status”‘;

转发的主要部分

upstream  local_img {
   server localhost:81;
   }
server{
       listen       81;
       server_name 127.0.0.1;
       location / {
                uwsgi_pass   127.0.0.1:9000;
                client_max_body_size   10m;
                include       uwsgi_params;
                access_log  off;
                autoindex off;
                }
    }

server {
       listen       80;
       server_name imgtest.simonzhang.net ;
       location / {
                #proxy cache stat
                proxy_redirect          off;
                proxy_set_header        Host            $host;
                proxy_set_header        X-Real-IP       $remote_addr;
                proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_connect_timeout   15;
                proxy_send_timeout      45;
                proxy_read_timeout      45;
                proxy_buffer_size       128k;
                proxy_buffers           4 128k;
                proxy_busy_buffers_size 128k;
                proxy_temp_file_write_size 128k;
                proxy_cache cache_one;
                # 成功浏览过的图片5天过期
                proxy_cache_valid 200 5d;
                proxy_cache_valid 404 304 1m;
                proxy_cache_key $host$uri$is_args$args;
                #add_header X-Cache $upstream_cache_status;
                proxy_pass http://local_img;
                #proxy cache end
                }
    }

  重启nginx服务后查看日志,日志中已经有了HIT的日志,日志显示使用处理耗时0.000ms。收工。

4月 19

hadoop运维问题1

2013-04-19 21:18:29,171 ERROR org.apache.hadoop.hdfs.server.datanode.DataNode: org.apache.hadoop.util.DiskChecker$DiskErrorException: Invalid value for volsFailed : 1 , Volumes tolerated : 0
at org.apache.hadoop.hdfs.server.datanode.FSDataset.(FSDataset.java:975)
at org.apache.hadoop.hdfs.server.datanode.DataNode.startDataNode(DataNode.java:389)
at org.apache.hadoop.hdfs.server.datanode.DataNode.(DataNode.java:299)
at org.apache.hadoop.hdfs.server.datanode.DataNode.makeInstance(DataNode.java:1582)
at org.apache.hadoop.hdfs.server.datanode.DataNode.instantiateDataNode(DataNode.java:1521)
at org.apache.hadoop.hdfs.server.datanode.DataNode.createDataNode(DataNode.java:1539)
at org.apache.hadoop.hdfs.server.datanode.DataNode.secureMain(DataNode.java:1665)
at org.apache.hadoop.hdfs.server.datanode.DataNode.main(DataNode.java:1682)

原因:磁盘损坏或链接失败
解决方案:通过hdfs的页面可以查到是那台服务器问题,在问题服务器上查看查看是那块硬盘的问题。紧急处理,停止该机的hdfs服务,在hadoop的hdfs-site.xml的配置中将损坏硬盘去掉,然后启动hdfs。之后尽快更换硬盘。

在恢复过程中使用“hadoop fsck /”查看当前状态。主要看“Missing replicas”副本丢失的比例,当数值为0%时,则恢复到系统设置的副本数量。
Minimally replicated blocks: 最小副本块完整的比例
Over-replicated blocks: 副本数高出设定默认复制级别参数的数据块文件所占比率
Under-replicated blocks: 副本数低于设定默认复制级别参数的数据块文件所占比率
Mis-replicated blocks: 丢失的副本块文件所占比率
Default replication factor: 默认副本数量
Average block replication: 实际平均副本数
Corrupt blocks: 损坏的block数
Missing replicas: 丢失的副本数
Number of data-nodes: 数据节点数
Number of racks: 机架数,如果没配置机架,默认都是1

3月 19

服务器上固态硬盘使用情况追踪测试

2012年8月17日 在服务器上装了一块固态硬盘,当时做了个测试
http://www.simonzhang.net/?p=1298

测试磁盘写能力
time dd if=/dev/zero of=/cache/test.dbf bs=8k count=300000
a

测试磁盘读能力
time dd if=/cache/test.dbf of=/dev/null bs=8k
b

  因为服务器还在工作,并且有20G的左右的缓存数据在使用,能保持这个效率还是不错。

查看一下磁盘健康情况,使用smartmontools工具
# yum install -y smartmontools

常用命令:
健康状况
smartctl -H /dev/hdb
列出错误日志。如果日志量过大,应该尽快更换
smartctl -l error /dev/hdb
所有信息
smartctl -a /dev/hdb

信息里面有温度,加电时间,等详细信息。

附录加载部分
/dev/system/root/ext4 discard,errors=remount-ro,noatime 0 1

3月 08

linux下查看使用硬盘IO过高的进程

  服务器cpu使用率不高,load比较高,所以要查看一下IO。硬盘IO可以通过命令vmstat或iostat获得(也可以用yum 安装dstat获得),网络IO可以用iftop命令获取。但是不知道那个进程使用硬盘IO比较高,通过查找没有找到相关命令,只好自己写个脚本进行统计处理。
  本脚本在CentOS6下(kernel2.6以上)python2.6测试通过。
  直接运行脚本,默认情况下收集3秒钟数据,显示读写最高的前三个进程。如用参数可以使用命令“python fhip.py 4 5 3”,第一个数位每次收集读写数据的间隔秒数,第二个数是打印出读写最多的n个进程,第三个为运行脚本的次数。因为参数部分写的比较简单那,所以用参数必须3个全写。

#!/bin/python 
#-*- coding:utf-8 -*- 
# Filename:    find_high_io_process
# Revision:    1.0 
# Date:        2013-3-8 
# Author:      simonzhang 
# web:         www.simonzhang.net 
# Email:       simon-zzm@163.com 
### END INIT INFO
import os
import re
import sys
import time
from string import strip

####
sys_proc_path = '/proc/'
re_find_process_number = '^\d+$'

####
# 通过/proc/$pid/io获取读写信息
####
def collect_info():
    _tmp = {}
    re_find_process_dir = re.compile(re_find_process_number)
    for i in os.listdir(sys_proc_path):
        if re_find_process_dir.search(i):
            # 获得进程名
            process_name = open("%s%s/stat" % (sys_proc_path, i), "rb").read().split(" ")[1]
            # 读取io信息
            rw_io = open("%s%s/io" % (sys_proc_path, i), "rb").readlines()
            for _info in rw_io:
                cut_info = strip(_info).split(':')
                if strip(cut_info[0]) == "read_bytes":
                    read_io = int(strip(cut_info[1]))
                if strip(cut_info[0]) == "write_bytes":
                    write_io = int(strip(cut_info[1]))
            _tmp[i] = {"name":process_name, "read_bytes":read_io, "write_bytes":write_io}
    return _tmp


def main(_sleep_time, _list_num):
    _sort_read_dict = {}
    _sort_write_dict = {}
    # 获取系统读写数据
    process_info_list_frist = collect_info()
    time.sleep(_sleep_time)
    process_info_list_second = collect_info()
    # 将读数据和写数据进行分组,写入两个字典中
    for loop in process_info_list_second.keys():
        second_read_v = process_info_list_second[loop]["read_bytes"]
        second_write_v = process_info_list_second[loop]["write_bytes"]
        try:
            frist_read_v = process_info_list_frist[loop]["read_bytes"]
        except:
            frist_read_v = 0
        try:
            frist_write_v = process_info_list_frist[loop]["write_bytes"]
        except:
            frist_write_v = 0
        # 计算第二次获得数据域第一次获得数据的差
        _sort_read_dict[loop] = second_read_v - frist_read_v
        _sort_write_dict[loop] = second_write_v - frist_write_v
    # 将读写数据进行排序
    sort_read_dict = sorted(_sort_read_dict.items(),key=lambda _sort_read_dict:_sort_read_dict[1],reverse=True)
    sort_write_dict = sorted(_sort_write_dict.items(),key=lambda _sort_write_dict:_sort_write_dict[1],reverse=True)
    # 打印统计结果
    print "pid     process     read(bytes) pid     process     write(btyes)"
    for _num in range(_list_num):
        read_pid = sort_read_dict[_num][0]
        write_pid = sort_write_dict[_num][0]
        res = "%s" % read_pid
        res += " " * (8 - len(read_pid)) + process_info_list_second[read_pid]["name"]
        res += " " * (12 - len(process_info_list_second[read_pid]["name"])) + "%s" % sort_read_dict[_num][1]
        res += " " * (12 - len("%s" % sort_read_dict[_num][1])) + write_pid
        res += " " * (8 - len(write_pid)) + process_info_list_second[write_pid]["name"]
        res += " " * (12 - len("%s" % process_info_list_second[write_pid]["name"])) + "%s" % sort_write_dict[_num][1]
        print res
    print "\n" * 1


if __name__ == '__main__':
    try:
        _sleep_time = sys.argv[1]
    except:
        _sleep_time = 3
    try:
        _num = sys.argv[2]
    except:
        _num = 3
    try:
        loop = sys.argv[3]
    except:
        loop = 1
    for i in range(int(loop)):
        main(int(_sleep_time), int(_num))

linux查找IO高的进程的源码