ผัก

Vegeta เป็นเครื่องมือทดสอบโหลด HTTP อเนกประสงค์ที่สร้างขึ้นจากความจำเป็นในการเจาะลึกบริการ HTTP ด้วยอัตราการร้องขอคงที่ 9000 กว่าแล้ว!

คุณสมบัติ

ใช้เป็นเครื่องมือบรรทัดคำสั่งและไลบรารี Go
CLI ออกแบบโดยคำนึงถึงความสามารถในการเขียน UNIX
หลีกเลี่ยงการละเว้นการประสานงานที่น่ารังเกียจ
ฟังก์ชั่นการรายงานที่ครอบคลุม
ใช้งานง่ายสำหรับการทดสอบโหลดแบบกระจาย
ติดตั้งและรันได้ง่าย (ไบนารีแบบคงที่ ตัวจัดการแพ็คเกจ ฯลฯ)

ติดตั้ง

ไฟล์ปฏิบัติการที่คอมไพล์ไว้ล่วงหน้า

รับพวกเขาที่นี่

ระบบปฏิบัติการ macOS

คุณสามารถติดตั้ง Vegeta โดยใช้ Homebrew:

$ brew update && brew install vegeta

หรือด้วย MacPorts:

$ port install vegeta

อาร์ค ลินุกซ์

$ pacman -S vegeta

ฟรีBSD

บน FreeBSD คุณสามารถติดตั้ง Vegeta ด้วยตัวจัดการแพ็คเกจในตัวได้เนื่องจากมี Vegeta Package ให้ใช้งาน

$ pkg install vegeta

แหล่งที่มา

git clone https://github.com/tsenart/vegeta
cd vegeta
make vegeta
mv vegeta ~ /bin # Or elsewhere, up to you.

การกำหนดเวอร์ชัน

ทั้งไลบรารีและ CLI ได้รับเวอร์ชันด้วย SemVer v2.0.0

หลังจากเวอร์ชัน 8.0.0 ทั้งสองคอมโพเนนต์จะได้รับเวอร์ชันแยกกันเพื่อแยกการเปลี่ยนแปลงที่เสียหายในแต่ละส่วนได้ดีขึ้น

การเผยแพร่ CLI ได้รับการแท็กด้วย cli/vMAJOR.MINOR.PATCH และเผยแพร่บนหน้าการเผยแพร่ GitHub สำหรับไลบรารีนั้น เวอร์ชันใหม่จะถูกแท็กทั้ง lib/vMAJOR.MINOR.PATCH และ vMAJOR.MINOR.PATCH แท็กหลังจำเป็นสำหรับการใช้งานร่วมกับ go mod

มีส่วนร่วม

ดูการมีส่วนร่วม.md

คู่มือการใช้งาน

 Usage: vegeta [global flags]  [command flags]

global flags:
  -cpus int
    	Number of CPUs to use (default = number of cpus)
  -profile string
    	Enable profiling of [cpu, heap]
  -version
    	Print version and exit

attack command:
  -body string
    	Requests body file
  -cert string
    	TLS client PEM encoded certificate file
  -chunked
    	Send body with chunked transfer encoding
  -connect-to value
    	A mapping of (ip|host):port to use instead of a target URL's (ip|host):port. Can be repeated multiple times.
    	Identical src:port with different dst:port will round-robin over the different dst:port pairs.
    	Example: google.com:80:localhost:6060
  -connections int
    	Max open idle connections per target host (default 10000)
  -dns-ttl value
    	Cache DNS lookups for the given duration [-1 = disabled, 0 = forever] (default 0s)
  -duration duration
    	Duration of the test [0 = forever]
  -format string
    	Targets format [http, json] (default "http")
  -h2c
    	Send HTTP/2 requests without TLS encryption
  -header value
    	Request header
  -http2
    	Send HTTP/2 requests when supported by the server (default true)
  -insecure
    	Ignore invalid server TLS certificates
  -keepalive
    	Use persistent connections (default true)
  -key string
    	TLS client PEM encoded private key file
  -laddr value
    	Local IP address (default 0.0.0.0)
  -lazy
    	Read targets lazily
  -max-body value
    	Maximum number of bytes to capture from response bodies. [-1 = no limit] (default -1)
  -max-connections int
    	Max connections per target host
  -max-workers uint
    	Maximum number of workers (default 18446744073709551615)
  -name string
    	Attack name
  -output string
    	Output file (default "stdout")
  -prometheus-addr string
    	Prometheus exporter listen address [empty = disabled]. Example: 0.0.0.0:8880
  -proxy-header value
    	Proxy CONNECT header
  -rate value
    	Number of requests per time unit [0 = infinity] (default 50/1s)
  -redirects int
    	Number of redirects to follow. -1 will not follow but marks as success (default 10)
  -resolvers value
    	List of addresses (ip:port) to use for DNS resolution. Disables use of local system DNS. (comma separated list)
  -root-certs value
    	TLS root certificate files (comma separated list)
  -session-tickets
    	Enable TLS session resumption using session tickets
  -targets string
    	Targets file (default "stdin")
  -timeout duration
    	Requests timeout (default 30s)
  -unix-socket string
    	Connect over a unix socket. This overrides the host address in target URLs
  -workers uint
    	Initial number of workers (default 10)

encode command:
  -output string
    	Output file (default "stdout")
  -to string
    	Output encoding [csv, gob, json] (default "json")

plot command:
  -output string
    	Output file (default "stdout")
  -threshold int
    	Threshold of data points above which series are downsampled. (default 4000)
  -title string
    	Title and header of the resulting HTML page (default "Vegeta Plot")

report command:
  -buckets string
    	Histogram buckets, e.g.: "[0,1ms,10ms]"
  -every duration
    	Report interval
  -output string
    	Output file (default "stdout")
  -type string
    	Report type to generate [text, json, hist[buckets], hdrplot] (default "text")

examples:
  echo "GET http://localhost/" | vegeta attack -duration=5s | tee results.bin | vegeta report
  vegeta report -type=json results.bin > metrics.json
  cat results.bin | vegeta plot > plot.html
  cat results.bin | vegeta report -type="hist[0,100ms,200ms,300ms]"

`-cpus`

ระบุจำนวน CPU ที่จะใช้ภายใน โดยค่าเริ่มต้นจะเป็นจำนวน CPU ที่มีอยู่ในระบบ

`-profile`

ระบุตัวสร้างโปรไฟล์ที่จะเปิดใช้งานระหว่างการดำเนินการ รองรับทั้งโปรไฟล์ cpu และ ฮีป มันไม่มีค่าเริ่มต้น

`-version`

พิมพ์เวอร์ชันและออก

คำสั่ง `attack`

`-body`

ระบุไฟล์ที่เนื้อหาจะถูกตั้งค่าเป็นเนื้อความของทุกคำขอ เว้นแต่จะถูกลบล้างต่อเป้าหมายการโจมตี โปรดดูที่ -targets

`-cert`

ระบุไฟล์ใบรับรองไคลเอ็นต์ TLS ที่เข้ารหัส PEM ที่จะใช้กับคำขอ HTTPS หากไม่ได้ระบุ -key จะถูกตั้งค่าเป็นค่าของแฟล็กนี้

`-chunked`

ระบุว่าจะส่งเนื้อหาคำขอด้วยการเข้ารหัสการถ่ายโอนแบบกลุ่มหรือไม่

`-connections`

ระบุจำนวนสูงสุดของการเชื่อมต่อที่เปิดอยู่ที่ไม่ได้ใช้งานต่อโฮสต์เป้าหมาย

`-dns-ttl`

ระบุระยะเวลาในการแคชการค้นหา DNS แคชค่าศูนย์ตลอดไป ค่าลบจะปิดใช้งานการแคชโดยสิ้นเชิง

`-max-connections`

ระบุจำนวนการเชื่อมต่อสูงสุดต่อโฮสต์เป้าหมาย

`-duration`

ระบุระยะเวลาในการออกคำขอไปยังเป้าหมาย การตั้งค่าโครงสร้างการทำงานพร้อมกันภายในมีค่านี้เป็นตัวแปร เวลารันจริงของการทดสอบอาจนานกว่าที่ระบุไว้เนื่องจากความล่าช้าในการตอบสนอง ใช้ 0 สำหรับการโจมตีที่ไม่มีที่สิ้นสุด

`-format`

ระบุรูปแบบเป้าหมายที่จะถอดรหัส

รูปแบบ `json`

รูปแบบ JSON ทำให้การรวมเข้ากับโปรแกรมที่สร้างเป้าหมายได้ง่ายขึ้นแบบไดนามิก แต่ละเป้าหมายคือออบเจ็กต์ JSON หนึ่งรายการในบรรทัดของตัวเอง ต้องระบุช่องวิธีการและ URL หากมี ฟิลด์เนื้อหาจะต้องเข้ารหัส base64 JSON Schema ที่สร้างขึ้นจะกำหนดรูปแบบโดยละเอียด

jq -ncM ' {method: "GET", url: "http://goku", body: "Punch!" | @base64, header: {"Content-Type": ["text/plain"]}} ' |
  vegeta attack -format=json -rate=100 | vegeta encode

รูปแบบ `http`

รูปแบบ http เกือบจะคล้ายกับรูปแบบข้อความ HTTP แบบข้อความธรรมดาที่กำหนดใน RFC 2616 แต่ไม่รองรับเนื้อหา HTTP ในบรรทัด โดยอ้างอิงถึงไฟล์ที่โหลดและใช้เป็นเนื้อหาคำขอเท่านั้น (ดังตัวอย่างด้านล่าง)

แม้ว่าเป้าหมายในรูปแบบนี้สามารถสร้างขึ้นได้โดยโปรแกรมอื่น แต่เดิมตั้งใจไว้สำหรับผู้ที่เขียนเป้าหมายด้วยมือสำหรับกรณีการใช้งานที่เรียบง่าย

ต่อไปนี้คือตัวอย่างบางส่วนของไฟล์เป้าหมายที่ถูกต้องในรูปแบบ http:

เป้าหมายง่ายๆ

 GET http://goku:9090/path/to/dragon?item=ball
GET http://user:password@goku:9090/path/to
HEAD http://goku:9090/path/to/success

เป้าหมายที่มีส่วนหัวที่กำหนดเอง

 GET http://user:password@goku:9090/path/to
X-Account-ID: 8675309

DELETE http://goku:9090/path/to/remove
Confirmation-Token: 90215
Authorization: Token DEADBEEF

เป้าหมายด้วยเนื้อความที่กำหนดเอง

 POST http://goku:9090/things
@/path/to/newthing.json

PATCH http://goku:9090/thing/71988591
@/path/to/thing-71988591.json

เป้าหมายที่มีเนื้อหาและส่วนหัวที่กำหนดเอง

 POST http://goku:9090/things
X-Account-ID: 99
@/path/to/newthing.json

เพิ่มความคิดเห็น

บรรทัดที่ขึ้นต้นด้วย # จะถูกละเว้น

 # get a dragon ball
GET http://goku:9090/path/to/dragon?item=ball
# specify a test account
X-Account-ID: 99

`-h2c`

ระบุว่าคำขอ HTTP2 จะถูกส่งผ่าน TCP โดยไม่มีการเข้ารหัส TLS

`-header`

ระบุส่วนหัวคำร้องขอที่จะใช้ในเป้าหมายทั้งหมดที่กำหนดไว้ โปรดดูที่ -targets คุณสามารถระบุได้มากเท่าที่ต้องการโดยทำซ้ำแฟล็ก

`-http2`

ระบุว่าจะเปิดใช้งานคำขอ HTTP/2 ไปยังเซิร์ฟเวอร์ที่รองรับหรือไม่

`-insecure`

ระบุว่าจะละเว้นใบรับรอง TLS ของเซิร์ฟเวอร์ที่ไม่ถูกต้องหรือไม่

`-keepalive`

ระบุว่าจะใช้การเชื่อมต่อ TCP ซ้ำระหว่างคำขอ HTTP หรือไม่

`-key`

ระบุไฟล์คีย์ส่วนตัวใบรับรองไคลเอ็นต์ TLS ที่เข้ารหัส PEM ที่จะใช้กับคำขอ HTTPS

`-laddr`

ระบุที่อยู่ IP ภายในเครื่องที่จะใช้

`-lazy`

ระบุว่าจะอ่านเป้าหมายอินพุตอย่างเกียจคร้านแทนที่จะอ่านอย่างกระตือรือร้นหรือไม่ ซึ่งช่วยให้สามารถสตรีมเป้าหมายเข้าสู่คำสั่งโจมตีและลดพื้นที่หน่วยความจำ การแลกเปลี่ยนเป็นหนึ่งในเวลาแฝงที่เพิ่มขึ้นในแต่ละการโจมตีเป้าหมาย

`-max-body`

ระบุจำนวนไบต์สูงสุดที่จะจับจากเนื้อความของแต่ละการตอบสนอง ไบต์ที่ยังไม่ได้อ่านที่เหลือจะถูกอ่านทั้งหมดแต่จะถูกละทิ้งไป ตั้งค่าเป็น -1 โดยไม่มีขีดจำกัด มันรู้วิธีตีความค่าเช่นนี้:

"10 MB" -> 10MB
"10240 g" -> 10TB
"2000" -> 2000B
"1tB" -> 1TB
"5 peta" -> 5PB
"28 kilobytes" -> 28KB
"1 gigabyte" -> 1GB

`-name`

ระบุชื่อของการโจมตีที่จะบันทึกในการตอบกลับ

`-output`

ระบุไฟล์เอาท์พุตที่จะใช้เขียนผลลัพธ์ไบนารี่ลงไป สร้างมาเพื่อส่งไปยังอินพุตคำสั่งรายงาน ค่าเริ่มต้นคือ stdout

`-rate`

ระบุอัตราการร้องขอต่อหน่วยเวลาที่จะออกให้กับเป้าหมาย อัตราคำขอจริงอาจแตกต่างกันเล็กน้อยเนื่องจากสิ่งต่างๆ เช่น การเก็บขยะ แต่โดยรวมแล้วควรใกล้เคียงกับที่ระบุมาก หากไม่มีหน่วยเวลา จะใช้ 1 วินาที

-rate 0 หรือ infinity หมายความว่า vegeta จะส่งคำขอโดยเร็วที่สุด ใช้ร่วมกับ -max-workers เพื่อสร้างโมเดลชุดคงที่ของผู้ใช้พร้อมกันที่ส่งคำขอแบบอนุกรม (เช่น รอการตอบกลับก่อนที่จะส่งคำขอถัดไป)

การตั้งค่า -max-workers เป็นตัวเลขที่สูงมากในขณะที่การตั้ง -rate=0 อาจส่งผลให้ vegeta ใช้ทรัพยากรมากเกินไปและหยุดทำงาน ใช้ด้วยความระมัดระวัง

`-redirects`

ระบุจำนวนการเปลี่ยนเส้นทางสูงสุดที่ติดตามในแต่ละคำขอ ค่าเริ่มต้นคือ 10 เมื่อค่าเป็น -1 ระบบจะไม่ติดตามการเปลี่ยนเส้นทาง แต่การตอบกลับจะถูกทำเครื่องหมายว่าสำเร็จ

`-resolvers`

ระบุที่อยู่ตัวแก้ไข DNS แบบกำหนดเองเพื่อใช้สำหรับการจำแนกชื่อ แทนที่จะเป็นที่อยู่ที่กำหนดโดยระบบปฏิบัติการ ใช้งานได้กับระบบที่ไม่ใช่ Windows เท่านั้น

`-root-certs`

ระบุไฟล์ใบรับรอง TLS root CAs ที่เชื่อถือได้เป็นรายการที่คั่นด้วยเครื่องหมายจุลภาค หากไม่ระบุ ระบบจะใช้ใบรับรอง CAs ของระบบเริ่มต้น

`-session-tickets`

ระบุว่าจะรองรับการเริ่มต้นเซสชัน TLS ใหม่โดยใช้ตั๋วเซสชันหรือไม่

`-targets`

ระบุไฟล์ที่จะอ่านเป้าหมาย โดยมีค่าเริ่มต้นเป็น stdin ดูส่วน -format เพื่อเรียนรู้เกี่ยวกับรูปแบบเป้าหมายต่างๆ

`-timeout`

ระบุการหมดเวลาสำหรับแต่ละคำขอ ค่า 0 ปิดใช้งานการหมดเวลา

`-workers`

ระบุจำนวนพนักงานเริ่มต้นที่ใช้ในการโจมตี จำนวนคนงานจริงจะเพิ่มขึ้นหากจำเป็นเพื่อรักษาอัตราที่ร้องขอ เว้นแต่ว่าจะเกินกว่า -max-workers

`-max-workers`

ระบุจำนวนพนักงานสูงสุดที่ใช้ในการโจมตี สามารถใช้เพื่อควบคุมระดับการทำงานพร้อมกันที่ใช้โดยการโจมตี

คำสั่ง `report`

 Usage: vegeta report [options] [...]

Outputs a report of attack results.

Arguments:
    A file with vegeta attack results encoded with one of
          the supported encodings (gob | json | csv) [default: stdin]

Options:
  --type    Which report type to generate (text | json | hist[buckets] | hdrplot).
            [default: text]

  --buckets Histogram buckets, e.g.: '[0,1ms,10ms]'

  --every   Write the report to --output at every given interval (e.g 100ms)
            The default of 0 means the report will only be written after
            all results have been processed. [default: 0]

  --output  Output file [default: stdout]

Examples:
  echo "GET http://:80" | vegeta attack -rate=10/s > results.gob
  echo "GET http://:80" | vegeta attack -rate=100/s | vegeta encode > results.json
  vegeta report results.*

`report -type=text`

 Requests      [total, rate, throughput] 1200, 120.00, 65.87
Duration      [total, attack, wait]     10.094965987s, 9.949883921s, 145.082066ms
Latencies     [min, mean, 50, 95, 99, max]  90.438129ms, 113.172398ms, 108.272568ms, 140.18235ms, 247.771566ms, 264.815246ms
Bytes In      [total, mean]             3714690, 3095.57
Bytes Out     [total, mean]             0, 0.00
Success       [ratio]                   55.42%
Status Codes  [code:count]              0:535  200:665
Error Set:
Get http://localhost:6060: dial tcp 127.0.0.1:6060: connection refused
Get http://localhost:6060: read tcp 127.0.0.1:6060: connection reset by peer
Get http://localhost:6060: dial tcp 127.0.0.1:6060: connection reset by peer
Get http://localhost:6060: write tcp 127.0.0.1:6060: broken pipe
Get http://localhost:6060: net/http: transport closed before response was received
Get http://localhost:6060: http: can't write HTTP request on broken connection

แถว Requests จะแสดง:

จำนวนคำขอที่ออก total
rate คำขอจริงที่ได้รับในระหว่างช่วง attack
throughput ของคำขอที่สำเร็จตลอดระยะเวลา total

แถว Duration จะแสดง:

เวลา attack ที่ใช้ในการออกคำขอทั้งหมด ( total - wait )
เวลา wait รอการตอบสนองต่อคำขอที่ออกล่าสุด ( total - attack )
เวลา total ที่ใช้ในการโจมตี ( attack + wait )

เวลาแฝงคือระยะเวลาที่ใช้ในการตอบสนองต่อคำขอที่จะอ่าน (รวมถึงไบต์ -max-body จากเนื้อหาการตอบสนอง)

min คือเวลาแฝงขั้นต่ำของคำขอทั้งหมดในการโจมตี
mean คือค่าเฉลี่ยเลขคณิต / ค่าเฉลี่ยของเวลาแฝงของคำขอทั้งหมดในการโจมตี
50 , 90 , 95 , 99 คือเปอร์เซ็นไทล์ที่ 50, 90, 95 และ 99 ตามลำดับ ของเวลาแฝงของคำขอทั้งหมดในการโจมตี เพื่อให้เข้าใจเพิ่มเติมว่าเหตุใดสิ่งเหล่านี้จึงมีประโยชน์ ฉันขอแนะนำบทความนี้จาก @tylertreat
max คือเวลาแฝงสูงสุดของคำขอทั้งหมดในการโจมตี

แถว Bytes In และ Bytes Out จะแสดง:

จำนวนไบต์ total ที่ส่ง (ออก) หรือรับ (เข้า) พร้อมกับเนื้อหาคำขอหรือการตอบสนอง
จำนวนไบต์ mean ที่ส่ง (ออก) หรือรับ (เข้า) พร้อมกับเนื้อหาคำขอหรือการตอบสนอง

อัตราส่วน Success แสดงเปอร์เซ็นต์ของคำขอที่การตอบสนองไม่มีข้อผิดพลาดและมีรหัสสถานะระหว่าง 200 ถึง 400 (ไม่รวม)

แถว Status Codes จะแสดงฮิสโตแกรมของรหัสสถานะ รหัสสถานะ 0 หมายถึงไม่สามารถส่งคำขอได้

Error Set จะแสดงชุดข้อผิดพลาดเฉพาะที่ส่งคืนโดยคำขอที่ออกทั้งหมด ซึ่งรวมถึงคำขอที่ได้รับรหัสสถานะการตอบกลับที่ไม่สำเร็จ

`report -type=json`

ระยะเวลาทั้งหมดเช่นฟิลด์อยู่ในหน่วยนาโนวินาที

{
  "latencies" : {
    "total" : 237119463 ,
    "mean" : 2371194 ,
    "50th" : 2854306 ,
    "90th" : 3228223 ,
    "95th" : 3478629 ,
    "99th" : 3530000 ,
    "max" : 3660505 ,
    "min" : 1949582
  },
  "buckets" : {
    "0" : 9952 ,
    "1000000" : 40 ,
    "2000000" : 6 ,
    "3000000" : 0 ,
    "4000000" : 0 ,
    "5000000" : 2
  },
  "bytes_in" : {
    "total" : 606700 ,
    "mean" : 6067
  },
  "bytes_out" : {
    "total" : 0 ,
    "mean" : 0
  },
  "earliest" : " 2015-09-19T14:45:50.645818631+02:00 " ,
  "latest" : " 2015-09-19T14:45:51.635818575+02:00 " ,
  "end" : " 2015-09-19T14:45:51.639325797+02:00 " ,
  "duration" : 989999944 ,
  "wait" : 3507222 ,
  "requests" : 100 ,
  "rate" : 101.01010672380401 ,
  "throughput" : 101.00012489812 ,
  "success" : 1 ,
  "status_codes" : {
    "200" : 100
  },
  "errors" : []
}

ในช่อง buckets แต่ละคีย์จะเป็นค่านาโนวินาทีที่แสดงถึงขอบเขตล่างของบัคเก็ต ขอบเขตบนหมายถึงกลุ่มที่สูงกว่าถัดไป ขอบเขตบนไม่รวมอยู่ด้วย ที่ฝากข้อมูลที่สูงที่สุดคือที่ฝากข้อมูลล้น มันไม่มีขอบเขตบน ค่านี้จะนับจำนวนคำขอที่อยู่ในที่เก็บข้อมูลนั้น หากไม่มีพารามิเตอร์ -buckets ฟิลด์ buckets จะถูกละไว้

`report -type=hist`

คำนวณและพิมพ์ฮิสโตแกรมตามข้อความสำหรับที่เก็บข้อมูลที่กำหนด ขอบเขตบนของที่เก็บข้อมูลแต่ละรายการจะไม่รวมอยู่ด้วย

 cat results.bin | vegeta report -type='hist[0,2ms,4ms,6ms]'
Bucket         #     %       Histogram
[0,     2ms]   6007  32.65%  ########################
[2ms,   4ms]   5505  29.92%  ######################
[4ms,   6ms]   2117  11.51%  ########
[6ms,   +Inf]  4771  25.93%  ###################

`report -type=hdrplot`

เขียนผลลัพธ์ในรูปแบบที่สามารถพล็อตได้โดย https://hdrhistogram.github.io/HdrHistogram/plotFiles.html

 Value(ms)  Percentile  TotalCount  1/(1-Percentile)
0.076715   0.000000    0           1.000000
0.439370   0.100000    200         1.111111
0.480836   0.200000    400         1.250000
0.495559   0.300000    599         1.428571
0.505101   0.400000    799         1.666667
0.513059   0.500000    999         2.000000
0.516664   0.550000    1099        2.222222
0.520455   0.600000    1199        2.500000
0.525008   0.650000    1299        2.857143
0.530174   0.700000    1399        3.333333
0.534891   0.750000    1499        4.000000
0.537572   0.775000    1548        4.444444
0.540340   0.800000    1598        5.000000
0.543763   0.825000    1648        5.714286
0.547164   0.850000    1698        6.666667
0.551432   0.875000    1748        8.000000
0.553444   0.887500    1773        8.888889
0.555774   0.900000    1798        10.000000
0.558454   0.912500    1823        11.428571
0.562123   0.925000    1848        13.333333
0.565563   0.937500    1873        16.000000
0.567831   0.943750    1886        17.777778
0.570617   0.950000    1898        20.000000
0.574522   0.956250    1911        22.857143
0.579046   0.962500    1923        26.666667
0.584426   0.968750    1936        32.000000
0.586695   0.971875    1942        35.555556
0.590451   0.975000    1948        40.000000
0.597543   0.978125    1954        45.714286
0.605637   0.981250    1961        53.333333
0.613564   0.984375    1967        64.000000
0.620393   0.985938    1970        71.113640
0.629121   0.987500    1973        80.000000
0.638060   0.989062    1976        91.424392
0.648085   0.990625    1979        106.666667
0.659689   0.992188    1982        128.008193
0.665870   0.992969    1984        142.227279
0.672985   0.993750    1986        160.000000
0.680101   0.994531    1987        182.848784
0.687810   0.995313    1989        213.356091
0.695729   0.996094    1990        256.016385
0.730641   0.996484    1991        284.414107
0.785516   0.996875    1992        320.000000
0.840392   0.997266    1993        365.764448
1.009646   0.997656    1993        426.621160
1.347020   0.998047    1994        512.032770
1.515276   0.998242    1994        568.828214
1.683532   0.998437    1995        639.795266
1.887487   0.998633    1995        731.528895
2.106249   0.998828    1996        853.242321
2.325011   0.999023    1996        1023.541453
2.434952   0.999121    1996        1137.656428
2.544894   0.999219    1996        1280.409731
2.589510   0.999316    1997        1461.988304
2.605192   0.999414    1997        1706.484642
2.620873   0.999512    1997        2049.180328
2.628713   0.999561    1997        2277.904328
2.636394   0.999609    1997        2557.544757
2.644234   0.999658    1997        2923.976608
2.652075   0.999707    1997        3412.969283
2.658916   0.999756    1998        4098.360656
2.658916   0.999780    1998        4545.454545
2.658916   0.999805    1998        5128.205128
2.658916   0.999829    1998        5847.953216
2.658916   0.999854    1998        6849.315068
2.658916   0.999878    1998        8196.721311
2.658916   0.999890    1998        9090.909091
2.658916   0.999902    1998        10204.081633
2.658916   0.999915    1998        11764.705882
2.658916   0.999927    1998        13698.630137
2.658916   0.999939    1998        16393.442623
2.658916   0.999945    1998        18181.818182
2.658916   0.999951    1998        20408.163265
2.658916   0.999957    1998        23255.813953
2.658916   0.999963    1998        27027.027027
2.658916   0.999969    1998        32258.064516
2.658916   0.999973    1998        37037.037037
2.658916   0.999976    1998        41666.666667
2.658916   0.999979    1998        47619.047619
2.658916   0.999982    1998        55555.555556
2.658916   0.999985    1998        66666.666667
2.658916   0.999986    1998        71428.571429
2.658916   0.999988    1998        83333.333333
2.658916   0.999989    1998        90909.090909
2.658916   0.999991    1998        111111.111111
2.658916   0.999992    1998        125000.000000
2.658916   0.999993    1998        142857.142858
2.658916   0.999994    1998        166666.666668
2.658916   0.999995    1998        199999.999999
2.658916   0.999996    1998        250000.000000
2.658916   0.999997    1998        333333.333336
2.658916   0.999998    1998        500000.000013
2.658916   0.999999    1998        999999.999971
2.658916   1.000000    1998        10000000.000000

คำสั่ง `encode`

 Usage: vegeta encode [options] [...]

Encodes vegeta attack results from one encoding to another.
The supported encodings are Gob (binary), CSV and JSON.
Each input file may have a different encoding which is detected
automatically.

The CSV encoder doesn't write a header. The columns written by it are:

  1. Unix timestamp in nanoseconds since epoch
  2. HTTP status code
  3. Request latency in nanoseconds
  4. Bytes out
  5. Bytes in
  6. Error
  7. Base64 encoded response body
  8. Attack name
  9. Sequence number of request
  10. Method
  11. URL
  12. Base64 encoded response headers

Arguments:
    A file with vegeta attack results encoded with one of
          the supported encodings (gob | json | csv) [default: stdin]

Options:
  --to      Output encoding (gob | json | csv) [default: json]
  --output  Output file [default: stdout]

Examples:
  echo "GET http://:80" | vegeta attack -rate=1/s > results.gob
  cat results.gob | vegeta encode | jq -c 'del(.body)' | vegeta encode -to gob

คำสั่ง `plot`

 Usage: vegeta plot [options] [...]

Outputs an HTML time series plot of request latencies over time.
The X axis represents elapsed time in seconds from the beginning
of the earliest attack in all input files. The Y axis represents
request latency in milliseconds.

Click and drag to select a region to zoom into. Double click to zoom out.
Choose a different number on the bottom left corner input field
to change the moving average window size (in data points).

Arguments:
    A file output by running vegeta attack [default: stdin]

Options:
  --title      Title and header of the resulting HTML page.
               [default: Vegeta Plot]
  --threshold  Threshold of data points to downsample series to.
               Series with less than --threshold number of data
               points are not downsampled. [default: 4000]

Examples:
  echo "GET http://:80" | vegeta attack -name=50qps -rate=50 -duration=5s > results.50qps.bin
  cat results.50qps.bin | vegeta plot > plot.50qps.html
  echo "GET http://:80" | vegeta attack -name=100qps -rate=100 -duration=5s > results.100qps.bin
  vegeta plot results.50qps.bin results.100qps.bin > plot.html

การใช้งาน: เป้าหมายที่สร้างขึ้น

นอกเหนือจากการยอมรับรายการเป้าหมายแบบคงที่แล้ว Vegeta ยังสามารถใช้ร่วมกับโปรแกรมอื่นที่สร้างเป้าหมายเหล่านั้นในรูปแบบการสตรีม นี่คือตัวอย่างการใช้ยูทิลิตี้ jq ที่สร้างเป้าหมายโดยมี id ที่เพิ่มขึ้นในร่างกาย

 jq -ncM 'while(true; .+1) | {method: "POST", url: "http://:6060", body: {id: .} | @base64 }' | 
  vegeta attack -rate=50/s -lazy -format=json -duration=30s | 
  tee results.bin | 
  vegeta report

การใช้งาน: การโจมตีแบบกระจาย

เมื่อใดก็ตามที่ไม่สามารถดำเนินการทดสอบโหลดของคุณได้เนื่องจากข้อจำกัดของเครื่อง Vegeta เช่น ไฟล์ที่เปิด, หน่วยความจำ, CPU หรือแบนด์วิดท์เครือข่าย เป็นความคิดที่ดีที่จะใช้ Vegeta ในลักษณะกระจาย

ในสถานการณ์สมมติที่อัตราการโจมตีที่ต้องการคือ 60,000 คำขอต่อวินาที สมมติว่าเรามีเครื่อง 3 เครื่องที่ติดตั้ง vegeta

ตรวจสอบให้แน่ใจว่าตัวอธิบายไฟล์ที่เปิดและขีดจำกัดกระบวนการถูกตั้งค่าเป็นตัวเลขที่สูงสำหรับผู้ใช้ของคุณ ในแต่ละเครื่อง โดยใช้คำสั่ง ulimit

เราพร้อมที่จะเริ่มการโจมตีแล้ว สิ่งที่เราต้องทำคือหารอัตราที่ต้องการด้วยจำนวนเครื่องจักร และใช้ตัวเลขนั้นในการโจมตีแต่ละครั้ง ที่นี่เราจะใช้ pdsh สำหรับการเรียบเรียง

$ PDSH_RCMD_TYPE=ssh pdsh -b -w ' 10.0.1.1,10.0.2.1,10.0.3.1 ' 
    ' echo "GET http://target/" | vegeta attack -rate=20000 -duration=60s > result.bin '

หลังจากคำสั่งก่อนหน้าเสร็จสิ้น เราก็สามารถรวบรวมไฟล์ผลลัพธ์เพื่อใช้ในรายงานของเราได้

$ for machine in 10.0.1.1 10.0.2.1 10.0.3.1 ; do
    scp $machine : ~ /result.bin $machine .bin &
  done

คำสั่ง report ยอมรับไฟล์ผลลัพธ์หลายไฟล์ มันจะอ่านและจัดเรียงตามเวลาประทับก่อนที่จะสร้างรายงาน

 vegeta report *.bin

อีกวิธีหนึ่งในการรวบรวมผลลัพธ์ในการทดสอบแบบกระจายคือการใช้ Prometheus Exporter ในตัวและกำหนดค่าเซิร์ฟเวอร์ Prometheus เพื่อรับผลการทดสอบจากอินสแตนซ์ Vegeta ทั้งหมด ดูตัวเลือก attack "prometheus-addr" สำหรับรายละเอียดเพิ่มเติมและตัวอย่างที่สมบูรณ์ในส่วน "การสนับสนุน Prometheus"

การใช้งาน: การวิเคราะห์แบบเรียลไทม์

หากคุณเป็นผู้ใช้ iTerm ที่พึงพอใจ คุณสามารถรวม vegeta เข้ากับ jplot โดยใช้ jaggr เพื่อพล็อตรายงาน vegeta แบบเรียลไทม์ในเทอร์มินัลของคุณอย่างสะดวกสบาย:

 echo 'GET http://localhost:8080' | 
    vegeta attack -rate 5000 -duration 10m | vegeta encode | 
    jaggr @count=rps 
          hist[100,200,300,400,500]:code 
          p25,p50,p95:latency 
          sum:bytes_in 
          sum:bytes_out | 
    jplot rps+code.hist.100+code.hist.200+code.hist.300+code.hist.400+code.hist.500 
          latency.p95+latency.p50+latency.p25 
          bytes_in.sum+bytes_out.sum

การใช้งาน: ห้องสมุด

การกำหนดเวอร์ชันไลบรารีเป็นไปตาม SemVer v2.0.0 ตั้งแต่ lib/v9.0.0 ไลบรารีและ cli จะได้รับเวอร์ชันแยกกันเพื่อแยกการเปลี่ยนแปลงที่เสียหายในแต่ละองค์ประกอบได้ดีขึ้น

ดูการกำหนดเวอร์ชันสำหรับรายละเอียดเพิ่มเติมเกี่ยวกับแผนการตั้งชื่อแท็ก git และความเข้ากันได้กับ go mod

 package main

import (
  "fmt"
  "time"

  vegeta "github.com/tsenart/vegeta/v12/lib"
)

func main () {
  rate := vegeta. Rate { Freq : 100 , Per : time . Second }
  duration := 4 * time . Second
  targeter := vegeta . NewStaticTargeter (vegeta. Target {
    Method : "GET" ,
    URL :    "http://localhost:9100/" ,
  })
  attacker := vegeta . NewAttacker ()

  var metrics vegeta. Metrics
  for res := range attacker . Attack ( targeter , rate , duration , "Big Bang!" ) {
    metrics . Add ( res )
  }
  metrics . Close ()

  fmt . Printf ( "99th percentile: %s n " , metrics . Latencies . P99 )
}

ข้อจำกัด

จะมีขอบเขตบนของ rate ที่รองรับซึ่งแตกต่างกันไปตามเครื่องที่ใช้งาน คุณอาจถูกผูกมัดกับ CPU (ไม่น่าเป็นไปได้) ถูกผูกไว้กับหน่วยความจำ (มีโอกาสมากกว่า) หรือทรัพยากรระบบถึงขีดจำกัดซึ่งควรได้รับการปรับแต่งสำหรับการดำเนินการตามกระบวนการ ข้อจำกัดที่สำคัญสำหรับเราคือตัวอธิบายไฟล์และกระบวนการ บนระบบ UNIX คุณสามารถรับและตั้งค่า soft-limit ปัจจุบันสำหรับผู้ใช้ได้

$ ulimit -n # file descriptors
2560
$ ulimit -u # processes / threads
709

เพียงส่งหมายเลขใหม่เป็นอาร์กิวเมนต์เพื่อเปลี่ยน

การสนับสนุนโพร

Vegeta มี Prometheus Exporter ในตัวที่อาจเปิดใช้งานระหว่างการโจมตี เพื่อให้คุณสามารถชี้อินสแตนซ์ Prometheus ไปยังกระบวนการโจมตี Vegeta และตรวจสอบตัววัดการโจมตีได้

หากต้องการเปิดใช้งาน Prometheus Exporter บนบรรทัดคำสั่ง ให้ตั้งค่าสถานะ "prometheus-addr"

ตำแหน่งข้อมูล Prometheus HTTP จะพร้อมใช้งานในช่วงอายุของการโจมตีเท่านั้น และจะถูกปิดทันทีหลังจากการโจมตีเสร็จสิ้น

มีการเปิดเผยเมตริกต่อไปนี้:

request_bytes_in - จำนวนไบต์ที่ได้รับจากเซิร์ฟเวอร์เป้าหมายตาม "url", "method" และ "status"
request_bytes_out

ขยาย

vegeta

ผัก

คุณสมบัติ

ติดตั้ง

ไฟล์ปฏิบัติการที่คอมไพล์ไว้ล่วงหน้า

ระบบปฏิบัติการ macOS

อาร์ค ลินุกซ์

ฟรีBSD

แหล่งที่มา

การกำหนดเวอร์ชัน

มีส่วนร่วม

คู่มือการใช้งาน

-cpus

-profile

-version

คำสั่ง attack

-body

-cert

-chunked

-connections

-dns-ttl

-max-connections

-duration

-format

รูปแบบ json

รูปแบบ http

เป้าหมายง่ายๆ

เป้าหมายที่มีส่วนหัวที่กำหนดเอง

เป้าหมายด้วยเนื้อความที่กำหนดเอง

เป้าหมายที่มีเนื้อหาและส่วนหัวที่กำหนดเอง

เพิ่มความคิดเห็น

-h2c

-header

-http2

-insecure

-keepalive

-key

-laddr

-lazy

-max-body

-name

-output

-rate

-redirects

-resolvers

-root-certs

-session-tickets

-targets

-timeout

-workers

-max-workers

คำสั่ง report

report -type=text

report -type=json

report -type=hist

report -type=hdrplot

คำสั่ง encode

คำสั่ง plot