[TOC]

0x01 处理器性能测试

stress 命令 - 系统压力基础测试(拷机)

描述:Stress/Stress-NG是Linux下两个常用的系统级压力测试工具,stress命令简单易用stress-ng是stress的升级版,支持数百个参数定制各种压CPU、内存、IO、网络的姿势。在系统过载的场景下,应用服务可能会出现意想不到的错误或异常,在测试负载均衡和熔断降级时非常有用。
这里只列举了几个常用的命令,详细使用参考”stress-ng –help”或”man stress-ng”。另外这些"烤机"命令来测试服务器性能也是不错的。

安装&语法:

1
2
3
4
5
6
7
8
9
10
# Install
RHRL/CentOS
yum install epel-release
yum install stress stress-ng

#Debian/Ubuntu
apt install stress stress-ng

# Syntax
# stress-ng 基本用法与stress完全兼容,但有更多的参数可选,并且可以查看统计信息;

基础实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
#1.在两个CPU核心上跑开方运算,并且启动一个不断分配释放1G内存的线程,运行10秒后停止
stress --cpu 2 --vm 1 --vm-bytes 1G -v --timeout 120

#2.启动一个线程不断执行sync系统调用回写磁盘缓存,并且启动一个线程不停地写入删除512MB数据,运行10秒停止
stress --io 1 --hdd 1 --hdd-bytes 512M -v --timeout 10

#3.--sock 可以模拟大量的socket连接断开以及数据的发送接收等等
stress-ng --sock 2 -v --timeout 10 --metrics-brief

#4.Note: Numbers may be suffixed with s,m,h,d,y (time) or B,K,M,G (size).
Example: stress --cpu 8 --io 4 --vm 2 --vm-bytes 128M --timeout 10s -v

Example: stress --cpu 24 --hdd 8 --hdd-bytes 1G --io 8 --vm 4 --vm-bytes 4G --timeout 1200s -v

WeiyiGeek.stress

WeiyiGeek.stress


0x02 磁盘性能测试

fio 命令 - 磁盘基准IO测试

描述:FIO是测试IOPS的非常好的工具(多线程或进程并执行),用来对磁盘进行基准测试和压力测试以及硬件验证等运维场景。磁盘IO是检查磁盘性能的重要指标,可以按照负载情况分成照顺序读写,随机读写两大类
特点: 19种不同类型的I/O引擎sync,mmap,libaio,posixaio,SG v3,splice,null,network,syslet,guasi,solarisaio
用途:编写和模拟的I/O负载匹配的作业文件测试磁盘设备的性能和网络存储的IO测试;
官网地址: http://freshmeat.net/projects/fio/
食用地址: https://github.com/axboe/fio

注意事项:千万不能在系统所在的分区测试硬盘性能否则您将跑路;

如何安装fio?

1
yum install fio -y

Fio命令参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
filename=/dev/sdb1 #测试文件名称通常选择需要测试的盘的data目录(测试必须指定切勿在系统分区做测试会破坏系统分区而导致系统崩溃无法启动)
directory=/app/ #在根目录下创建一个空目录,在测试命令中使用directory参数指定该目录,而不使用filename参数。
direct=1 #使用directIO绕过OS自带的 buffer 使测试磁盘的结果更真实(bool类型)。
rw=read #read(顺序读)| randread(随机读) | write(顺序写) | randwrite (随机写) | randrw (混合随机读写模式) 5种方式
rwmixwrite=30 #在混合读写的模式下写占30%
rwmixread=70 #在混合读写的模式下写占70%
bs=16k #设置I/O block块文件大小为16k(默认4k)
bsrange=512-2048 #提定数据块的大小范围
name=jobname #任务的名称(且任务名称可以相同)
numjobs=1 #每个job(任务)开1个线程 最终线程数=任务数(几个name=jobx) * numjobs
size=5G #指定job处理的文件的大小及每个线程读写的数据量
runtime=1000 #指定在多少秒后停止进程,此处测试时间为1000秒
ioengine=libaio #I/O引擎选择(一共19种),默认值是sync同步阻塞I/O , libaio是Linux的本地native异步I/O。
iodepth=16 #队列的深度,如果ioengine采用异步方式,该参数表示一批提交保持的io单元数
lockmem=1g #使用1g内存进行测试。
nrfiles=8 #每个进程生成文件的数量。
time_based #如果在runtime指定的时间还没到时文件就被读写完成,将继续重复知道runtime时间结束。
thread #使用pthread_create创建线程,另一种是fork创建进程,由于进程的开销比线程要大所以一般都采用thread测试;
zero_buffers #用0初始化系统buffer。
group_reporting #当同时指定了numjobs了时,输出结果按组显示

磁盘读写常用测试点:

  1. Read=100% Ramdon=100% rw=randread (100%随机读)
  2. Read=100% Sequence=100% rw=read (100%顺序读)
  3. Write=100% Sequence=100% rw=write (100%顺序写)
  4. Write=100% Ramdon=100% rw=randwrite (100%随机写)
  5. Read=70% Sequence=100% rw=rw, rwmixread=70, rwmixwrite=30 (70%顺序读,30%顺序写)
  6. Read=70% Ramdon=100% rw=randrw, rwmixread=70, rwmixwrite=30 (70%随机读,30%随机写)


补充说明:

  • Linux读写的时候内核维护了缓存数据先写到缓存后面再后台写到SSD(一般的raid卡何sas卡都带有缓存机制)。读的时候也优先读缓存里的数据(速度可以加快),但是一旦掉电缓存里的数据就没了;所以有一种模式叫做DirectIO跳过缓存直接读写SSD
  • 在异步模式下CPU不能一直无限的发命令到SSD:比如SSD执行读写如果发生了卡顿,那有可能系统会一直不停的发命令/几千个/甚至几万个,这样一方面SSD扛不住,另一方面这么多命令会很占内存,系统也要挂掉了,所以就带来一个参数叫做队列深度。

基础实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#实例1.本地异步I/O 4k 块 不使用系统缓存  读测试 测试深度16 时间60s
$fio -filename=/dev/sdb/ -name="BS 4KB read test" -ioengine=libaio -direct=1 -thread -rw=read -size=1M -numjobs=16 -bs=4k -iodepth=16 -runtime=60 -time_based -group_reporting

$fio -directory=/app/ -name="BS 4KB read test" -ioengine=libaio -direct=1 -thread -rw=read -size=1M -numjobs=16 -bs=4k -iodepth=16 -runtime=60 -time_based -group_reporting

$fio --bs=4k --ioengine=libaio --iodepth=1 --direct=1 --rw=read --time_based --runtime=60 --refill_buffers --norandommap --randrepeat=0 --group_reporting --name=fio-read --size=500M --filename=/dev/sdb1


示例2.配置文件形式:fio.conf
#测试命令
fio fio.conf
cat > fio.comf <<END
[global]
ioengine=libaio
direct=1
thread=1
norandommap=1
randrepeat=0
runtime=60
ramp_time=6
size=1g
directory=/data
[read4k-rand]
stonewall
group_reporting
bs=4k
rw=randread
numjobs=8
iodepth=32
[read64k-seq]
stonewall
group_reporting
bs=64k
rw=read
numjobs=4
iodepth=8
[write4k-rand]
stonewall
group_reporting
bs=4k
rw=randwrite
numjobs=2
iodepth=4
[write64k-seq]
stonewall
group_reporting
bs=64k
rw=write
numjobs=2
iodepth=4
END

测试结果以及说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#测试2:
Jobs: 16 (f=16): [R(16)][100.0%][r=9941KiB/s,w=0KiB/s][r=2485,w=0 IOPS][eta 00m:00s]
BS 4KB read test: (groupid=0, jobs=16): err= 0: pid=2637: Tue Apr 28 21:27:01 2020
#读IOPS #BW=平均IO带宽 #runt=线程运行时间
read: IOPS=2457, BW=9830KiB/s (10.1MB/s)(577MiB/60060msec)
#slat=提交延迟,提交该IO请求到kernel所花的时间(不包括kernel处理的时间)
slat (nsec): min=1665, max=243925k, avg=5226953.48, stdev=13063402.61
#clat=完成延迟, 提交该IO请求到kernel后,处理所花的时间
clat (usec): min=85, max=698388, avg=98913.96, stdev=63432.35
#lat=响应时间
lat (usec): min=88, max=698392, avg=104141.19, stdev=67428.64
clat percentiles (msec):
| 1.00th=[ 41], 5.00th=[ 47], 10.00th=[ 50], 20.00th=[ 53],
| 30.00th=[ 56], 40.00th=[ 61], 50.00th=[ 77], 60.00th=[ 95],
| 70.00th=[ 114], 80.00th=[ 140], 90.00th=[ 182], 95.00th=[ 224],
| 99.00th=[ 326], 99.50th=[ 380], 99.90th=[ 489], 99.95th=[ 550],
| 99.99th=[ 625]
#带宽
bw ( KiB/s): min= 40, max= 1696, per=6.24%, avg=613.88, stdev=285.96, samples=1920
iops : min= 10, max= 424, avg=153.45, stdev=71.50, samples=1920
lat (usec) : 100=0.01%, 250=0.02%, 500=0.16%, 750=0.07%, 1000=0.04%
lat (msec) : 2=0.08%, 4=0.01%, 10=0.02%, 20=0.04%, 50=12.59%
lat (msec) : 100=49.84%, 250=33.90%, 500=3.12%, 750=0.09%
#利用率
cpu : usr=0.02%, sys=0.11%, ctx=74903, majf=0, minf=285
#io队列深度
IO depths : 1=0.1%, 2=0.1%, 4=0.1%, 8=0.1%, 16=99.8%, 32=0.0%, >=64=0.0%
#单个IO提交要提交的IO数
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
#类似于上面的提交号,但是用于补全。
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.1%, 32=0.0%, 64=0.0%, >=64=0.0%
#发出的读/写请求的数量,
issued rwts: total=147602,0,0,0 short=0,0,0,0 dropped=0,0,0,0
#IO完延迟的分布
latency : target=0, window=0, percentile=100.00%, depth=16

Run status group 0 (all jobs):
READ: bw=9830KiB/s (10.1MB/s), 9830KiB/s-9830KiB/s (10.1MB/s-10.1MB/s), io=577MiB (605MB), run=60060-60060msec

Disk stats (read/write):
# ios=所有group总共执行的IO数.
# merge=总共发生的IO合并数.
# ticks=Number of ticks we kept the disk busy.
# io_queue=花费在队列上的总共时间.
# util=磁盘利用率
vda: ios=147591/7, merge=0/3, ticks=7606987/26, in_queue=7607671, util=99.88%


#测试3
Starting 1 process
Jobs: 1 (f=0): [R] [38.4% done] [4031KB/0KB/0KB /s] [1007/0/0 iops] [eta 01m:38s]
fio-read: (groupid=0, jobs=1): err= 0: pid=15639: Tue Apr 28 21:45:02 2020
read : io=195600KB, bw=3259.1KB/s, iops=814, runt= 60001msec
slat (usec): min=14, max=5370, avg=34.54, stdev=89.26
clat (usec): min=3, max=1537.2K, avg=1179.49, stdev=8932.97
lat (usec): min=75, max=1537.2K, avg=1216.66, stdev=8933.38
clat percentiles (usec):
| 1.00th=[ 141], 5.00th=[ 227], 10.00th=[ 290], 20.00th=[ 410],
| 30.00th=[ 532], 40.00th=[ 684], 50.00th=[ 844], 60.00th=[ 988],
| 70.00th=[ 1176], 80.00th=[ 1448], 90.00th=[ 1864], 95.00th=[ 2320],
| 99.00th=[ 6112], 99.50th=[13760], 99.90th=[23680], 99.95th=[31104],
| 99.99th=[154624]
bw (KB /s): min= 19, max= 4552, per=100.00%, avg=3371.60, stdev=989.34
lat (usec) : 4=0.01%, 10=0.02%, 50=0.01%, 100=0.23%, 250=6.35%
lat (usec) : 500=20.69%, 750=16.90%, 1000=16.37%
lat (msec) : 2=31.73%, 4=6.07%, 10=0.86%, 20=0.59%, 50=0.15%
lat (msec) : 100=0.01%, 250=0.01%, 2000=0.01%
cpu : usr=1.62%, sys=5.57%, ctx=49057, majf=0, minf=9
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=48900/w=0/d=0, short=r=0/w=0/d=0

Run status group 0 (all jobs):
READ: io=195600KB, aggrb=3259KB/s, minb=3259KB/s, maxb=3259KB/s, mint=60001msec, maxt=60001msec

Disk stats (read/write):
sdb: ios=48651/0, merge=0/0, ticks=55536/0, in_queue=55468, util=92.82%

WeiyiGeek.

WeiyiGeek.


0x03 网络性能测试

iperf 命令 - C/S结构下网络性能测试

描述:Iperf是一款强大的网络性能测试工具基于CS模式。主要测试一些网络设备如路由器,防火墙,交换机等的性能。

Iperf具有跨平台的特性,它支持Linux、Windows,Android,MacOS X,FreeBSD,OpenBSD,NetBSD,Vxworks,Solaris等;

Iperf3是最新版本,也是功能最强大的一个版本, Iperf3与原始Iperf版本不共享代码,也不向后兼容。

iPerf分为iperf2和iperf3版本,iperf3不支持全双工模式。

主要功能:

  • 网络测速测试TCP和UDP带宽(bandwidth)、延迟抖动(jitter)和数据包丢失(lost packet rate)。
  • 开发的宽带集群通信系统中

下载地址:https://iperf.fr/iperf-download.php

1
2
3
4
5
6
7
8
#命令安装
tar xvfiperf-3.0b5.tar.gz
cd iperf-3.0b5
./configure
make && make install

#yum安装
yum install iperf


服务器的特定参数:

1
2
3
4
5
6
7
s,-server
在服务器模式下运行iperf,且一次只允许一个iperf连接。
-D,-damon
在后台运行服务器作为守护程序。
-I,-pidfile文件
使用进程ID编写一个文件,作为守护进程运行时最为有用(iperf3.1版本新功能)
-p:后接服务端监听的端口

客户端的特定参数:

1
2
3
4
5
6
7
8
9
-c, -c  主机地址
在客户端模式下运行Iperf,连接到在主机上运行的Iperf服务器
-u 使用UDP而不是TCP,详见-b选项
-b, bandwidth n 将目标带宽设置为n bits/sec(UDP默认为1 Mbits / sec,TCP无限制)。
-t, -time n 设置传输的时间(以秒为单位),默认发送10秒的数据
-R, 上传速度机械能测试
-4 指定ipv4
-f 格式化带宽数输出
-n 指定传输的字节数

通用参数:

1
2
-i:设置带宽报告的时间间隔,单位为秒
-B: 绑定C/S的ip地址

基础实例:

1
2
3
4
5
6
7
8
9
10
#实例1.机器带宽检测
iperf3 -s -i 1 #Server
iperf3 -c 172.31.0.25 -i 1 -t 10 60 #Client

[ ID] Interval Transfer Bandwidth Retr Cwnd
[ 4] 0.00-1.00 sec 697 MBytes 5.84 Gbits/sec 0 3.01 MBytes

[ ID] Interval Transfer Bandwidth (带宽数) Retr
[ 4] 0.00-10.00 sec 7.07 GBytes 6.07 Gbits/sec 2006 sender
[ 4] 0.00-10.00 sec 7.07 GBytes 6.07 Gbits/sec receiver

WeiyiGeek.

WeiyiGeek.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#示例2.测试单线程UDP
iperf -s -u
iperf -c 172.31.0.25-u -t 15 -i 1

#示例3.测试流量为10Mbps
iperf -u -c 192.168.90.234 -b 10M-i -2

#示例4.Linux设备和Android设备测试UDP带宽
iperf -s -u #以在本服务器启用iperf,并运行于udp模式
iperf -c server-ip -u -t 15 -i 1 # 在客户端(Android)

#示例5.上传速度测试
iperf -c ip -p 5204 -R

#示例6.绑定指定IP
iperf -s -p 25001 -B 192.168.33.103 (-u)
iperf -c -p 25001 -B 192.168.33.104 -4 -f K -n 10M -b 10M (-u)

执行效果:在此时间段,用户的终端到服务器的UDP带宽大致为683Kbps,时延抖动为9.730ms,已知的云服务器的总带宽约为136KBps,即1.06Mbps(可以多次测量求得用户终端到服务器的实际带宽)

WeiyiGeek.

WeiyiGeek.


qperf 命令 - 网络连接传输性能测试

描述:该qperf命令是测试两个节点之间的带宽和延时(测量RDMA和IP性能),为此需要一个当作服务端一个当作客户端即(C/S架构)。其中服务端直接运行qperf无需任何参数。该工具使用本身和netperf/iperf非常类似,但是除了支持tcp/udp/sctp外还可以支持RDMA测量,以及进行循环遍历测试。

安装与帮助:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# Install
yum install -y qperf
apt install qperf

# 基础语法
qperf SERVERNODE [OPTIONS] TESTS
qperf --help examples #Some examples of using qperf

# 参数说明
man qperf

# 测试选项
Miscellaneous
conf Show configuration
quit Cause the server to quit
Socket Based
rds_bw RDS streaming one way bandwidth
rds_lat RDS one way latency
sctp_bw SCTP streaming one way bandwidth
sctp_lat SCTP one way latency
tcp_bw TCP streaming one way bandwidth
tcp_lat TCP one way latency
udp_bw UDP streaming one way bandwidth
udp_lat UDP one way latency
RDMA Send/Receive
rc_bi_bw RC streaming two way bandwidth
rc_bw RC streaming one way bandwidth
rc_lat RC one way latency
uc_bi_bw UC streaming two way bandwidth
uc_bw UC streaming one way bandwidth
uc_lat UC one way latency
ud_bi_bw UD streaming two way bandwidth
ud_bw UD streaming one way bandwidth
ud_lat UD one way latency
xrc_bi_bw XRC streaming two way bandwidth
xrc_bw XRC streaming one way bandwidth
xrc_lat XRC one way latency
RDMA
rc_rdma_read_bw RC RDMA read streaming one way bandwidth
rc_rdma_read_lat RC RDMA read one way latency
rc_rdma_write_bw RC RDMA write streaming one way bandwidth
rc_rdma_write_lat RC RDMA write one way latency
rc_rdma_write_poll_lat RC RDMA write one way polling latency
uc_rdma_write_bw UC RDMA write streaming one way bandwidth
uc_rdma_write_lat UC RDMA write one way latency
uc_rdma_write_poll_lat UC RDMA write one way polling latency
InfiniBand Atomics
rc_compare_swap_mr RC compare and swap messaging rate
rc_fetch_add_mr RC fetch and add messaging rate
Verification
ver_rc_compare_swap Verify RC compare and swap
ver_rc_fetch_add Verify RC fetch and add

基础语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# 0.服务端直接运行如下,无需任何参数
$ qperf #此时终端阻塞
# 默认开启端口号:19765
# 通过netstat查看,如下:
$ netstat -tunlup
# tcp 0 0 0.0.0.0:19765 0.0.0.0:* LISTEN 53755/qperf

# 1.客户端运行TCP/UDP带宽和延迟测试:
qperf -t 30 10.10.107.192 -v tcp_bw udp_bw tcp_lat udp_lat conf
# tcp_bw:
# bw = 672 MB/sec
# msg_rate = 10.2 K/sec
# time = 30 sec
# send_cost = 1.52 sec/GB
# recv_cost = 1.78 sec/GB
# send_cpus_used = 102 % cpus
# recv_cpus_used = 120 % cpus
# udp_bw:
# send_bw = 514 MB/sec
# recv_bw = 3.52 MB/sec
# msg_rate = 108 /sec
# time = 30 sec
# send_cost = 1.91 sec/GB
# recv_cost = 101 sec/GB
# send_cpus_used = 98 % cpus
# recv_cpus_used = 35.5 % cpus
# tcp_lat:
# latency = 95.9 us
# msg_rate = 10.4 K/sec
# time = 30 sec
# loc_cpus_used = 32.8 % cpus
# rem_cpus_used = 28.6 % cpus
# udp_lat:
# latency = 83.4 us
# msg_rate = 12 K/sec
# time = 30 sec
# loc_cpus_used = 29.6 % cpus
# rem_cpus_used = 28.2 % cpus
# conf:
# loc_node = master-01
# loc_cpu = 2 Cores: Intel Core i3 540 @ 3.07GHz
# loc_os = Linux 5.7.0-1.el7.elrepo.x86_64
# loc_qperf = 0.4.9
# rem_node = master-02
# rem_cpu = 2 Cores: Intel Core i3 540 @ 3.07GHz
# rem_os = Linux 5.7.0-1.el7.elrepo.x86_64
# rem_qperf = 0.4.9

# 2.客户端运行测量RDMA UD的延迟和带宽:
qperf myserver ud_lat ud_bw

# 3.客户端运行测量RDMA UC双向带宽:
qperf myserver rc_bi_bw

# 4.客户端运行获取消息大小从1到64K的TCP延时范围
qperf myserver -oo msg_size:1:64K:*2 -vu tcp_lat


0x04 网站压力测试

wrk 命令 - HTTP 压力测试工

描述:wrk 是一个比较先进的 HTTP 压力测试工具,当在单个多核 CPU 上运行时,能够产生大量负载。它结合了多线程设计和可扩展的事件通知系统,例如 epoll 和 kqueue。

下载地址:

安装&语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Install
git clone https://github.com/wg/wrk.git --depth=1 && cd wrk && make

# Syntax
Usage: wrk <options> <url>
Options:
-c, --connections <N> Connections to keep open 需要模拟的个并发请求连接数量
-d, --duration <T> Duration of test 测试的测试时长
-t, --threads <N> Number of threads to use 并发线程数量
-s, --script <S> Load Lua script file 指定 Lua 脚本的路径
-H, --header <H> Add header to request 指定请求带的 Header 参数
--latency Print latency statistics 是否打印请求延迟统计
--timeout <T> Socket/request timeout 设置请求超时时间

Numeric arguments may include a SI unit (1k, 1M, 1G)
Time arguments may include a time unit (2s, 2m, 2h)

基础实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#实例1.八线程400个请求测试10分钟
wrk -t8 -c400 -d10m http://localhost:8080/index.html
#输出结果:
Making 10000000 requests to http://localhost:8080/index.html
8 threads and 400 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 439.75us 350.49us 7.60ms 92.88%
Req/Sec 61.13k 8.26k 72.00k 87.54%
10000088 requests in 19.87s, 3.42GB read
Requests/sec: 503396.23 #QPS
Transfer/sec: 176.16MB

#示例2.#实例1.八线程400个请求测试10分钟
wrk -t8 -c400 -H "accept-encoding: gzip" -d1m http://localhost:8080/index.html


httperf 命令 - 高效的 http 压力测试工具

描述:Httperf 是由HP开发的一个衡量Web服务器性能的工具,它提供了用于产生各种HTTP工作量和测定服务器性能的柔性设施。使用它可以模拟出超过1千的并发访问,能充分测试出 web server 的性能;

httperf的重点不是实现一个特定的基准,但在提供一个强大的,高性能的工具,有利于微观和宏观层面的基准建设,httperf的三个显着特征是其鲁棒性,其包括,以产生和维持服务器过载,为对HTTP/1.1和SSL协议的支持,并且它的可扩展到新工作负荷发电机和性能测量的能力。

官网地址: https://github.com/httperf/httperf

应用场景:

  • 1.Nginx性能测试

安装&语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# Centos 安装 autoreconf
$ yum -y install install autoconf automake libtool
$ git clone https://github.com/httperf/httperf.git
# 注意:如果从CVS仓库出口建设的源代码,而不是官方的gzip压缩的源tar文件,下面的命令必须在前面的那些之前执行
$ autoreconf -i
$ ./configure
$ make && make install

# 生成二进制程序路径 ./src/httperf
# 所有可用选项的列表可以通过指定--help选项得到(全选名称可以,只要他们保持明确的缩写)
httperf -h
Usage: httperf [-hdvV] [--add-header S] [--burst-length N] [--client N/N]
[--close-with-reset] [--debug N] [--failure-status N]
[--help] [--hog] [--http-version S] [--max-connections N]
[--max-piped-calls N] [--method S] [--no-host-hdr]
[--num-calls N] [--num-conns N] [--session-cookies]
[--period [d|u|e]T1[,T2]|[v]T1,D1[,T2,D2]...[,Tn,Dn]
[--print-reply [header|body]] [--print-request [header|body]]
[--rate X] [--recv-buffer N] [--retry-on-failure] [--send-buffer N]
[--server S|--servers file] [--server-name S] [--port N] [--uri S] [--myaddr S]
[--think-timeout X] [--timeout X] [--verbose] [--version]
[--wlog y|n,file] [--wsess N,N,X] [--wsesslog N,X,file]
[--wset N,X]
[--runtime X]
[--use-timer-cache]
[--periodic-stats]

# 参数解释:
--client=I/N #指定当前客户端I,是N个客户端中的第几个。用于多个客户端发请求,希望确保每个客户端发的请求不是完全一致。一般不用指定
--server URL # 指定测试地址 域名或者IP
--port 端口 # 指定服务端口
--uri 路径 # 指定测试web端的地址
--rate 速率 # 指定请求速率
--num-conns 连接数 # 指定创建的连接数
--num-calls 调用数 # 指定每个连接发送多少请求
--send-buffer # 指定发送http请求的最大buffer,默认为4K,一般不用指
--recv-buffer # 指定接受http请求的最大buffer,默认为16K,一般不用指定
--timeout # 设置超时时间

基础语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
# 实例1.调用的httperf的最简单的方法
httperf --server blog.weiyigeek.top --port 443 # 默认请求参数如下即实际执行命令如下
# 实际执行: httperf --client=0/1 --server=blog.weiyigeek.top --port=443 --uri=/ --send-buffer=4096 --recv-buffer=16384 --num-conns=1 --num-calls=1
Maximum connect burst length: 0
# 结果总结:多个TCP连接是如何由客户端,有多少请求而发送的,有多少收到答复,什么总测试时间为启动。
#下面表明1个连接被启动的线,进行1个请求和收到1页的答复。它还表明总测试时间为0.435秒,意味着平均请求速率为每秒几乎正好0.5请求。
Total: connections 1 requests 1 replies 1 test-duration 0.435 s
# 用来与Web服务器通信的TCP连接的信息,连接被以每秒2.3连接的速率启动,该速度对应于周期的每个连接434.6毫秒。
Connection rate: 2.3 conn/s (434.6 ms/conn, <=1 concurrent connections)
# 成功的连接寿命的统计数据
Connection time [ms]: min 434.6 avg 434.6 max 434.6 median 434.5 stddev 0.0
# 统计是平均花费的时间建立一个TCP连接到服务器(所有成功的TCP连接机构进行计数,可能已经最终未能甚至连接)
Connection time [ms]: connect 217.3
# 每个连接中接收到答复的平均数量。与常规的HTTP/1.0,该值至多为1.0(当没有故障),但随着保持HTTP或HTTP / 1.1持久连接,这个值可以是任意高的,其表明在相同的连接被用来接收多个响应。
Connection length [replies/conn]: 1.000

# 请求速率与以字节为单位的HTTP请求的大小
Request rate: 2.3 req/s (434.6 ms/req)
Request size [B]: 71.0
# 为获得有意义的标准偏差,建议运行每个测试足够长的时间,以便获得至少30个样品,这将对应于至少150秒,即两分半钟的测试持续时间。
Reply rate [replies/s]: min 0.0 avg 0.0 max 0.0 stddev 0.0 (0 samples)
# 过了多长时间的服务器响应多久它采取收到回复信息
Reply time [ms]: response 217.3 transfer 0.0
Reply size [B]: header 161.0 content 253.0 footer 0.0 (total 414.0)
Reply status: 1xx=0 2xx=0 3xx=0 4xx=1 5xx=0

CPU time [s]: user 0.20 system 0.24 (user 45.1% system 54.9% total 100.0%)

# 以每秒千字节的平均网络吞吐量(其中一千字节是1024个字节)和以每秒兆比特(其中,a是兆位10 ^ 6位)
Net I/O: 1.1 KB/s (0.0*10^6 bps);

# 在测试期间发生的错误的统计数据
Errors: total 0 client-timo 0 socket-timo 0 connrefused 0 connreset 0
Errors: fd-unavail 0 addrunavail 0 ftab-full 0 other 0


# 实例3.设置连接数以及速率
$ httperf --server 10.20.172.196 --port 80 --num-conns 300 --rate 100 --timeout 5
# 实际执行: httperf --timeout=5 --client=0/1--server=10.0.172.196 --port=80 --uri=/index.html --rate=100 --send-buffer=4096--recv-buffer=16384 --num-conns=300 --num-calls=5

Maximum connect burst length: 13
#• 最大并发连接数:13
Total: connections 300 requests 1475 replies 1475test-duration 6.204 s
#• 一共300个连接,1475个请求,应答了1475个,测试耗时:6.204秒
Connection rate: 48.4 conn/s (20.7 ms/conn, <=189concurrent connections)
#• 连接速率:48.4个每秒(每个连接耗时20.7 ms, 小于指定的300个并发连接)
Connection time [ms]: min 663.4 avg 1937.6 max 3808.4median 1720.5 stddev 964.7
#• 连接时间(微秒):最小663.4,平均1937.6,最大3808.4,中位数 1720.5, 标准偏差964.7
Connection time [ms]: connect 1098.4
#• 连接时间(微秒):连接1098.4
Connection length [replies/conn]: 5.000
#• 连接长度(应答/连接):5.000
Request rate: 237.7 req/s (4.2 ms/req)
#• 请求速率:237.7(pqs),每个请求4.2 ms
Request size : 79.0
#• 连接长度(应答/连接): 79.0
Reply rate [replies/s]: min 268.8 avg 268.8 max 268.8stddev 0.0 (1 samples)
#• 响应速率(响应个数/秒):最小268.8, 平均268.8,最大268.8,标准偏差 0.0(一个例样)
Reply time [ms]: response 80.7 transfer 87.2
#• 响应时间(微妙):响应80.7,传输87.2
Reply size : header 283.0 content 21895.0 footer 0.0(total 22178.0)
#• 应包长度(字节):响应头283.0 内容:21895.0 响应末端 -0.0(总共22178.0)
Reply status: 1xx=0 2xx=1475 3xx=0 4xx=0 5xx=0
#• 响应包状态: 2xx 有1475个,其他没有
CPU time [s]: user 0.45 system 5.48 (user 7.3% system88.3% total 95.6%)
#• CPU时间(秒): 用户0.45 系统5.48(用户占了7.3% 系统占88.3% 总共95.6%)
Net I/O: 5167.4 KB/s (42.3*10^6 bps)
#• 网络I/O:5167.4 KB/s
Errors: total 5 client-timo 5 socket-timo 0 connrefused 0connreset 0
#• 错误:总数5 客户端超时5 套接字超时0 连接拒绝0 连接重置0
Errors: fd-unavail 0 addrunavail 0 ftab-full 0 other 0
#• 错误:fd不正确0 地址不正确0 ftab占满0其他0


# 实例4.以下是 gzip 格式访问的测试数据(因缓存文件以 gzip 格式保存,所以性能是最高的)
httperf --server weiyigeek.top -num-conns 2000 --add-header "accept-encoding: gzip"
#deflate (2级压缩率)格式访问的统计数据(需要从 gzip 解压,再压缩为 deflate 的数据处理)
httperf --server weiyigeek.top -num-conns 2000 --add-header "accept-encoding: deflate"
#normal 文本格式访问的统计数据
httperf --server weiyigeek.top --num-conns 2000 --add-header "accept-encoding: normal"
# 实际运行:httperf --client=0/1 -server=weiyigeek.top --port=80 --uri=/ --send-buffer=4096 --recv-buffer=16384 --add-header='accept-encoding: gzip' --num-conns=2000 --num-calls=1

补充说明:

  • (1) 计算并发处理结果 = Num-conns / Request rate
  • (2) 连接时间中位数,每组数中如果是奇数则取中间值,偶数则取两个中间值/2


ab 命令 - Apache的HTTP服务器基准测试工具

描述:AB(是apachebench命令缩写)是标杆Apache的超文本传输​​协议(HTTP)服务器的工具。它的目的是给你如何你当前的Apache安装执行的印象。这尤其显示了每秒Apache安装能够服务的多少个请求,它还可以用于nginx、tomcat、IIS等服务;

官网帮助文档地址:http://httpd.apache.org/docs/2.4/programs/ab.html

安装&语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 方式1.源码安装apache后ab命令存放在apache安装目录的bin目录下
/usr/local/apache2/bin

# 方式2.通过yum的RPM包方式安装的ab命令默认存放在/usr/bin目录下
which ab
$/usr/bin/ab

# 方式3.如果不想安装apache但是又想使用ab命令情况下
yum -y install httpd-tools


# Syntax
-n 在测试会话中所执行的请求个数。默认时,仅执行一个请求。
-c 一次产生的请求个数。默认是一次一个。
-t 测试所进行的最大秒数。其内部隐含值是-n 50000,它可以使对服务器的测试限制在一个固定的总时间以内。默认时,没有时间限制。
-p 包含了需要POST的数据的文件。
-P 对一个中转代理提供BASIC认证信任。用户名和密码由一个:隔开,并以base64编码形式发送。无论服务器是否需要(即, 是否发送了401认证需求代码),此字符串都会被发送。
-T POST数据所使用的Content-type头信息。
-v 设置显示信息的详细程度-4或更大值会显示头信息,3或更大值可以显示响应代码(404,200等),2或更大值可以显示警告和其他信息。
-V 显示版本号并退出。
-w 以HTML表的格式输出结果。默认时,它是白色背景的两列宽度的一张表。
-i 执行HEAD请求,而不是GET。
-x 设置<table>属性的字符串。
-X 对请求使用代理服务器。
-y 设置<tr>属性的字符串。
-z 设置<td>属性的字符串。
-C 对请求附加一个Cookie:行。其典型形式是name=value的一个参数对,此参数可以重复。
-H 对请求附加额外的头信息。此参数的典型形式是一个有效的头信息行,其中包含了以冒号分隔的字段和值的对(如,"Accept-Encoding:zip/zop;8bit")。
-A 对服务器提供BASIC认证信任。用户名和密码由一个:隔开,并以base64编码形式发送。无论服务器是否需要(即,是否发送了401认证需求代码),此字符串都会被发送。
-h 显示使用方法。
-d 不显示"percentage served within XX [ms] table"的消息(为以前的版本提供支持)。
-e 产生一个以逗号分隔的(CSV)文件,其中包含了处理每个相应百分比的请求所需要(从1%到100%)的相应百分比的(以微妙为单位)时间。由于这种格式已经"二进制化",所以比'gnuplot'格式更有用。
-g 把所有测试结果写入一个'gnuplot'或者TSV(以Tab分隔的)文件。此文件可以方便地导入到Gnuplot,IDL,Mathematica,Igor甚至Excel中。其中的第一行为标题。
-i 执行HEAD请求,而不是GET。
-k 启用HTTP KeepAlive功能,即在一个HTTP会话中执行多个请求。默认时,不启用KeepAlive功能。
-q 如果处理的请求数大于150,ab每处理大约10%或者100个请求时,会在stderr输出一个进度计数。此-q标记可以抑制这些信息。

基础实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# 实例1.ab命令常用选项参数
╭─[email protected]test ~
╰─$ab -n 1000 -c 1000 http://10.20.172.196/
This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
Benchmarking 10.20.172.196 (be patient)
Completed 100 requests
....
Completed 1000 requests
Finished 1000 requests
# 测试目标站点信息 #
#被测试的Web服务器软件名称
Server Software: nginx/1.15.8.1
#表示请求的URL主机名
Server Hostname: 10.20.172.196
#表示被测试的Web服务器软件的监听端口
Server Port: 80
#表示请求的URL中的根绝对路径,通过该文件的后缀名
Document Path: /
#表示HTTP响应数据的正文长度。
Document Length: 649 bytes
#表示并发用户数,我们设置的参数之一。
Concurrency Level: 1000
#表示所有这些请求被处理完成所花费的总时间。
Time taken for tests: 0.107 seconds
#表示总请求数量,我们设置的参数之一。
Complete requests: 1000
#表示失败的请求数量,这里的失败是指请求在连接服务器、发送数据等环节发生异常,以及无响应后超时的情况
Failed requests: 0
Write errors: 0
#表示所有请求的响应数据长度总和,包括每个HTTP响应数据的头信息和正文数据的长度
Total transferred: 888000 bytes
#表示所有请求的响应数据中正文数据的总和,实际是减去了Total transferred中HTTP响应数据中的头信息的长度。
HTML transferred: 649000 bytes
#[重点] QPS 吞吐率 = Complete requests/Time taken for tests (越高,服务器性能越好)
Requests per second: 9313.50 [#/sec] (mean)
#[重点] 用户平均请求等待时间= Time token for tests/ (Complete requests/Concurrency Level)
Time per request: 107.371 [ms] (mean)
Time per request: 0.107 [ms] (mean, across all concurrent requests)
#[重点] 表示这些请求在单位时间内从服务器获取的数据长度=Total trnasferred/Time taken for tests,该统计很好的说明服务器的处理能力达到极限时,其出口宽带的需求量。
Transfer rate: 8076.55 [Kbytes/sec] received
# 每次请求平均连接时间
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 29 8.1 29 42
Processing: 17 36 14.3 45 51
Waiting: 0 35 14.3 44 50
Total: 42 65 9.0 64 87

# 用于描述每个请求处理时间的分布情况
Percentage of the requests served within a certain time (ms)
50% 64
66% 69
75% 71
80% 73
90% 78
95% 81
98% 84
99% 86
100% 87 (longest request)

补充说明:

  • (1) ab软件在进行性能测试过程主要性能指标:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    #1.吞吐率(Requests per second)
    服务器并发处理能力的量化描述(单位是reqs/s),指的是在某个并发用户数下单位时间内处理的请求数。某个并发用户数下单位时间内能处理的最大请求数,称之为最大吞吐率。

    记住:吞吐率是基于并发用户数的,代表了两个含义:
    a、吞吐率和并发用户数相关
    b、不同的并发用户数下,吞吐率一般是不同的

    计算公式:总请求数/处理完成这些请求数所花费的时间,即 Request per second=Complete requests/Time taken for tests
    必须要说明的是,这个数值表示当前机器的整体性能,值越大越好。

    #2、并发连接数(The number of concurrent connections)
    并发连接数指的是某个时刻服务器所接受的请求数目,简单的讲,就是一个会话。

    #3、并发用户数(Concurrency Level)
    要注意区分这个概念和并发连接数之间的区别,一个用户可能同时会产生多个会话也即连接数。在HTTP/1.1下,IE7支持两个并发连接,IE8支持6个并发连接,FireFox3支持4个并发连接,所以相应的,我们的并发用户数就得除以这个基数。

    #4、用户平均请求等待时间(Time per request)
    计算公式:处理完成所有请求数所花费的时间/(总请求数/并发用户数),即:
    Time per request = Time taken for tests/(Complete requests/Concurrency Level)

    #5、服务器平均请求等待时间(Time per request:across all concurrent requests)
    计算公式:处理完成所有请求数所花费的时间/总请求数,即:
    Time taken for/testsComplete requests

    可以看到,它是吞吐率的倒数。
    同时,它也等于用户平均请求等待时间/并发用户数,即 Time per request/Concurrency Level