tkuchiki's blog

Alias to run "git switch" regardless of whether the default branch is main or master.

Mon, 31 Oct 2022 00:00:00 +0900

GitHub has changed the default branch from master to main, but repositories created before the change may still be master.
You can git switch them by creating the following alias and running the gitswdb.

alias gitswdb="git switch $(git symbolic-ref refs/remotes/origin/HEAD | cut -f4 -d'/')"

If you are using git checkout, rewriting switch to checkout should work.

Fastly's request condition is applied to the latest matching condition

Tue, 06 Apr 2021 00:00:00 +0900

If you want Fastly to switch origin (backend) according to a condition, you can do so by setting a request condition. I misunderstood the behavior of the request condition and got into trouble, so I’ll show you what I misunderstood and how I dealt with it.

Request condition

The Request condition has a priority, and the default is 10. The lower the value, it will be evaluated first, and all request conditions will be evaluated. The following is an example of a request condition.

Request condition 1
- priority: 10
- condition: req.http.host == "foo.example.com" && req.url.path ~ "^/v2"
- backend: bar.example.com
Request condition 2
- priority: 20
- condition: req.http.host == "foo.example.com"
- backend: foo.example.com

With this configuration, I thought that a request for foo.example.com/v2/ping would set the backend to bar.example.com and a request for foo.example.com/v1/ping would set the backend to foo.example.com. However, the backend for foo.example.com/v2/ping was set to foo.example.com. This is because the request conditions are evaluated in ascending order of priority, but matching the conditions does not stop them from being evaluated. The above request conditions are VCL as follows.

# Request Condition: api_v2 Prio: 10
if( req.http.host == "foo.example.com" && req.url.path ~ "^/v2/" ) {
set req.backend = F_bar_example_com;
}
#end condition
# Request Condition: api_v1 Prio: 20
if( req.http.host == "foo.example.com" ) {
set req.backend = F_foo_example_com;
}
#end condition

If statements are generated as there are request conditions. if a condition with a high priority value is matched, the backend will be that one. When setting the request conditions, you must be aware of one of the following:

Set a condition that does not match more than one request condition
Set priorities appropriately to ensure that multiple request conditions match the intended behavior

How to convert to lowercase and uppercase in bash, awk, sed, and, tr and the benchmark results for each

Sat, 03 Apr 2021 00:00:00 +0900

This article introduces how to convert to lowercase and uppercase in bash, awk, sed, and tr, and the benchmark results for each.

Versions

The versions are as follows:

OS
- Ubuntu 20.04.1 LTS
bash
- GNU bash, version 5.0.17(1)-release (x86_64-pc-linux-gnu)
gawk
- GNU Awk 5.0.1, API: 2.0 (GNU MPFR 4.0.2, GNU MP 6.2.0)
mawk
- 1.3.4 20200120
sed
- sed (GNU sed) 4.7
tr
- tr (GNU coreutils) 8.30

Convert to lowercase/uppercase

bash

The documentation says the following:

The ‘^’ operator converts lowercase letters matching pattern to uppercase; the ‘,’ operator converts matching uppercase letters to lowercase. The ‘^^’ and ‘,,’ expansions convert each matched character in the expanded value;

# to lower
$ val="AAA"
$ echo ${val,,}
aaa

# to upper
$ val="aaa"
$ echo ${val^^}
AAA

awk

The documentations says that there are functions called tolower and toupper.

# to lower
$ echo AAA | awk '{print tolower($0)}'
aaa

# to upper
$ echo aaa | awk '{print toupper($0)}'
AAA

sed

The documentation says the following:

\L Turn the replacement to lowercase until a \U or \E is found,

\U Turn the replacement to uppercase until a \L or \E is found,

# to lower
$ echo AAA | sed -e 's/\(.*\)/\L\1/'
aaa

# to upper
$ echo aaa | sed -e 's/\(.*\)/\U\1/'
AAA

However, \L and \U cannot be used in BSD sed.

tr

The documentation says the following:

[:lower:] all lower case letters

[:upper:] all upper case letters

# to lower
$ echo AAA | tr '[:upper:]' '[:lower:]'
aaa

# to upper
$ echo aaa | tr '[:lower:]' '[:upper:]'
AAA

The above is how to convert to lowercase and uppercase.

Benchmark

Benchmark the performance of each. Will use hyperfine for benchmarking.

Generate script

To convert strings of various lengths, write the following script to generate a script that executes commands on arbitrary-length strings.

#!/bin/bash

n=${1}

str=$(perl -e "print 'a' x ${n}")

cat <<EOF > bash-n${n}.sh
v=${str}; echo \${v^^}
EOF

cat <<EOF > tr-n${n}.sh
echo ${str} | tr '[:lower:]' '[:upper:]'
EOF

cat <<EOF > sed-n${n}.sh
echo ${str} | sed -e 's/\(.*\)/\U\1/'
EOF

cat <<EOF > gawk-n${n}.sh
echo ${str} | gawk '{print toupper(\$0)}'
EOF

cat <<EOF > mawk-n${n}.sh
echo ${str} | mawk '{print toupper(\$0)}'
EOF

cat <<EOF > benchmark-n${n}.sh
hyperfine --warmup 3 --min-runs 1000 "bash bash-n${n}.sh" "bash tr-n${n}.sh" "bash sed-n${n}.sh" "bash gawk-n${n}.sh" "bash mawk-n${n}.sh" --export-markdown benchmark-result-n${1}.md
EOF

If the above script called gen-scripts.sh, run it as gen-scripts.sh 10 to generate a script that executes commands against aaaaaaaaa(length = 10) and benchmarks them with hyperfine. Since it is unlikely that the results will change between lowercase and uppercase conversions, benchmark only for uppercase conversions.

Results

Benchmarked the string lengths as 10, 100, 1,000, 10,000, 100,000, and 1,000,000. *-n10.sh has a string length of 10, *-n100.sh has a string length of 100, … and so on. The benchmark was done on Ubuntu 20.04.1, but since the first installed awk was mawk, so also measured it with gawk.

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
`bash bash-n10.sh`	2.2 ± 0.5	1.5	6.3	1.00
`bash tr-n10.sh`	3.1 ± 0.6	2.4	9.6	1.43 ± 0.44
`bash sed-n10.sh`	3.3 ± 0.5	2.7	6.7	1.55 ± 0.44
`bash gawk-n10.sh`	3.9 ± 0.7	3.1	8.5	1.81 ± 0.54
`bash mawk-n10.sh`	3.3 ± 0.6	2.5	6.7	1.52 ± 0.46

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
`bash bash-n100.sh`	1.6 ± 0.3	1.1	3.3	1.00
`bash tr-n100.sh`	2.6 ± 0.5	1.8	6.1	1.70 ± 0.45
`bash sed-n100.sh`	2.8 ± 0.5	2.2	5.6	1.79 ± 0.46
`bash gawk-n100.sh`	3.4 ± 0.6	2.6	6.8	2.16 ± 0.55
`bash mawk-n100.sh`	2.7 ± 0.5	2.0	6.4	1.70 ± 0.45

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
`bash bash-n1000.sh`	2.3 ± 0.5	1.6	7.2	1.00
`bash tr-n1000.sh`	3.2 ± 1.3	2.4	19.0	1.44 ± 0.66
`bash sed-n1000.sh`	4.6 ± 2.2	2.8	24.1	2.02 ± 1.08
`bash gawk-n1000.sh`	4.1 ± 0.9	3.1	8.9	1.83 ± 0.57
`bash mawk-n1000.sh`	3.2 ± 0.4	2.6	6.3	1.40 ± 0.37

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
`bash bash-n10000.sh`	3.1 ± 0.4	2.4	7.3	1.00
`bash tr-n10000.sh`	3.4 ± 0.6	2.6	6.1	1.11 ± 0.25
`bash sed-n10000.sh`	5.7 ± 26.5	3.8	842.7	1.84 ± 8.62
`bash gawk-n10000.sh`	4.4 ± 0.7	3.4	7.6	1.44 ± 0.31
`bash mawk-n10000.sh`	3.4 ± 0.4	2.7	5.5	1.10 ± 0.21

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
`bash bash-n100000.sh`	17.1 ± 1.4	14.8	29.4	1.63 ± 0.20
`bash tr-n100000.sh`	10.5 ± 1.0	8.9	15.8	1.00
`bash sed-n100000.sh`	21.2 ± 1.6	19.0	39.2	2.02 ± 0.24
`bash gawk-n100000.sh`	12.8 ± 1.0	11.0	19.1	1.22 ± 0.15
`bash mawk-n100000.sh`	11.9 ± 0.7	10.7	18.3	1.13 ± 0.13

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
`bash bash-n1000000.sh`	144.8 ± 11.2	126.3	206.8	1.89 ± 0.19
`bash tr-n1000000.sh`	77.4 ± 6.9	67.1	143.5	1.01 ± 0.11
`bash sed-n1000000.sh`	172.3 ± 13.6	151.1	276.5	2.24 ± 0.23
`bash gawk-n1000000.sh`	84.3 ± 5.4	75.4	103.7	1.10 ± 0.10
`bash mawk-n1000000.sh`	76.8 ± 5.0	68.8	128.3	1.00

The results are summarized as follow:

For string lengths of 1,000 or less, conversion by bash’s variable expansion is the fastest.
At a string length of 10,000, bash’s variable expansion, tr, and mawk, become almost as fast.
Bash’s variable expansion slows down when the string length 100,000 or higher, and tr, mawk, and gawk are faster.
The performance of tr and mawk will always be about the same.
sed is the slowest in all results.
Perhaps because the process was simple, there was not much difference in performance between gawk and mawk.

Conclusion

This article introduces how to convert to lowercase and uppercase in bash, awk, sed, and tr, and the benchmark results for each. However, since there is only a 2-fold difference in performance between top and bottom, think there is no problem using the command you like as long as it is not executed too often. Also, since CPU and memory usage is not measured in hyperfine, choosing which one to use will change when you consider those factors as well.

Conver an array of JSON objects to the Markdown table

Tue, 30 Mar 2021 00:00:00 +0900

This article is introduction to json2mdtbl, a cli tool that converts an array of JSON objects into a Markdown table.

Installation

Download from https://github.com/tkuchiki/json2mdtbl/releases and place it in a location where your PATH environment variable can find it(e.g. /usr/local/bin).

Usage

It’s easy to use, just pipe in JSON or ndjson.

$ echo '[{"name": "alice", "age": 10},{"name":"bob", "age": 20}]' | json2mdtbl
| AGE | NAME |
|-----|-------|
| 10 | alice |
| 20 | bob |

$ echo -e '{"name": "alice", "age": 10}\n{"name":"bob", "age": 20}' | json2mdtbl
| AGE | NAME |
|-----|-------|
| 10 | alice |
| 20 | bob |

You can use it to get BigQuery results as JSON and put them into a Markdown table!

Introduction to kubectls

Thu, 18 Mar 2021 00:00:00 +0900

kubectls is a kubectl version manager.
This is a kubectl version of tools like *env(kubectlenv).

Installation

You can install it with the following command: Think it will work if you have bash, ln, readlink, curl, and git installed.

$ git clone https://github.com/tkuchiki/kubectls ~/.kubectls

Set the PATH to give priority to ~/.kubectls/bin in .bashrc. If you are using zsh, replace it with .zshrc.

# for bash
$ echo "PATH=~/.kubectls/bin:\$PATH" >> ~/.bashrc
$ echo "export $PATH" >> ~/.bashrc

Usage

kubectls consists of 5 subcommands. Introduction to them one by one.

$ kubectls --help
Usage: kubectls

kubectls is kubectl version manager

Commands:
 install Install kubectl
 path Show current kubectl's abs path
 update Update kubectls
 use Set version
 versions Show installed versions

Options:
 --version Show version

install

The install subcommand is an installing kubectl.

$ kubectls install --help
Usage: kubectl install (VERSION|stable) [--set]

Install kubectl

Options:
 --set Set version

You can install the stable version of kubectl with kubectl install stable.

$ kubectls install stable
 % Total % Received % Xferd Average Speed Time Time Time Current
 Dload Upload Total Spent Left Speed
100 44.1M 100 44.1M 0 0 16.3M 0 0:00:02 0:00:02 --:--:-- 16.3M

v1.20.4 is installed

You can install the specified version of kubectl with kubectls install VERSION.

$ kubectls install v1.20.0
 % Total % Received % Xferd Average Speed Time Time Time Current
 Dload Upload Total Spent Left Speed
100 44.0M 100 44.0M 0 0 17.5M 0 0:00:02 0:00:02 --:--:-- 17.5M

v1.20.0 is installed

kubectls install just installs it. It will not become usable. To switch to the specified version, you can run kubectls use(see below) or kubectls install with the option --use.

$ kubectls install v1.20.1 --use
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 44.0M 100 44.0M 0 0 20.7M 0 0:00:02 0:00:02 --:--:-- 20.7M
v1.20.1 is installed
v1.20.1 selected
$ kubectl version --client --short
Client Version: v1.20.1

use

This is a subcommand to switch to the version of kubectl that you installed with kubectls install.

$ kubectls use --help
Usage: kubectl use [VERSION]

Set version

You can switch to the specific version with kubectls use VERSION.

$ kubectls use v1.20.4
v1.20.4 selected

You can switch to the specific version by selecting from the list of installed versions.

$ kubectls use
1) v1.20.0
2) v1.20.1
3) v1.20.2
4) v1.20.4
Which version? 3
v1.20.2 selected

path

Print the absolute path of the kubectl currently be used.

$ kubectls path --help
Usage: kubectl path

Show current kubectl's abs path

$ kubectls path
/Users/tkuchiki/.kubectls/versions/v1.20.2/kubectl

versions

Prints a list of installed versions.

$ kubectls versions --help
Usage: kubectl versions

Show installed versions

$ kubectls versions
v1.20.0
v1.20.1
v1.20.2
v1.20.4

update

Update kubectls.

$ kubectls update --help
Usage: kubectl update

Update kubectls

Conclusion

This article was an introduction to kubectls. You may not switch between multiple versions very often, but I hope this helps you!

Open the file in JetBrains IDE by specifying the line that matches the search

Thu, 11 Mar 2021 00:00:00 +0900

This article is an introduction to searching for a string in a file using ag or pt and specify the matching line to open in JetBrains IDE.

The way to open a file from the command line in the JetBrains IDE is the same for all of them, so will use Goland as an example. You can configure it on Windows, macOS, and Linux that are supported by the JetBrains IDE, but in this article, the only introduction to macOS.

Create a shell script

Enables Goland to be run as a command.
Place the following files in a location where your PATH environment variable can find it(e.g. /usr/local/bin).

#!/bin/sh

open -na "GoLand.app" --args "${@}"

Grant the execute permissions.

$ chmod +x /usr/local/bin/goland

You can rewrite the "Goland.app" to "IntelliJ IDEA.app" and change /usr/local/bin/goland to /usr/local/bin/idea to make the settings for IntelliJ IDEA. If you want to use a different IDE, change it accordingly.

Refer to the manual for instructions if you are using the Toolbox App.

Open files from the command line

The following command will open the file in Goland.

$ goland nosplash /path/to/file

nosplash is an option to prevent the splash screen from appearing when Goland is loaded.

The command to open a file by specifying a line is as follows:

$ goland nosplash --line NUMBER /path/to/file

Search for strings and open matching lines

Use peco for the command line selector and ag for string search (skip the details usage of each). If you want to use pt, replace ag with pt.
Add the following function to your .bashrc or .zshrc and reload it.

ag-goland() {
 local selected_line=$(ag "${@}" | peco --query "$LBUFFER")
 if [ "${selected_line}" != "" ]; then
 if [ -f "${2}" ]; then
 goland nosplash --line $(echo ${selected_line} | awk -F':' '{print $1}') ${2}
 else
 goland nosplash --line $(echo ${selected_line} | awk -F':' '{print $2, $1}')
 fi
 fi
}

If no file matches the string search, or if you stop the execution with Ctrl-C while selecting with peco, nothing will be done. The second argument of ag is made to work with both directories and files, but the implementation is designed to specify only one file, so please be careful about that.

The usage is as follows:

$ ag-goland PATTERN /path/to/dir
$ ag-goland PATTERN /path/to/file

Conclusion

This article was an introduction to searching for a string in a file and specify the matching line to open in Goland.
If you want to open a file within a project, you may not need to use it since you can do the same thing with the IDE functionality, but if you want to open a file by searching across various projects, you may be able to use it.

References

Clear the container logs on Docker Desktop for Mac

Fri, 19 Oct 2018 00:00:00 +0900

This article is an introduction to clearing the container logs in Docker Desktop for Mac.
The version at the time of writing is Docker Desktop for Mac 3.2.2(61853).

About Docker Desktop for Mac

You can run docker inspect to get the path to the container log file.

$ docker inspect CONTAINER_ID --format "{{.LogPath}}"
/var/lib/docker/containers/3d0305c254c33ff5e78d675f45e60fdcef65937ed8b53e21baf07f818d34ce9b/3d0305c254c33ff5e78d675f45e60fdcef65937ed8b53e21baf07f818d34ce9b-json.log

If you have dockerd and containerd running on the same host as the docker container on Linux, you can cleaer the logs with a command like the following:

$ sudo truncate $(docker inspect CONTAINER_ID --format "{{.LogPath}}") --size 0
$ sudo bash -c ":> $(docker inspect CONTAINER_ID --format "{{.LogPath}}")"

However, if you run docker inspect on Docker Desktop for Mac on macOS, you can get the path to the log file, but you cannot clear the log using the above way because /var/lib/docker is not present on macOS. This is because running LinuxKit, a lightweight Linux, in a virtualized environment called HyperKit on macOS, and running containerd on it.

+------------+
| containerd |
+------------+
| LinuxKit |
+------------+
| HyperKit |
+------------+
| macOS |
+------------+

If you need to clear the container logs in the Docker Desktop for Mac, you need to clear the log files on LinuxKit, not macOS.

Connect to the LinuxKit

https://docs.docker.com/docker-for-mac/release-notes/#docker-desktop-community-2400 says to open the shell with the following command:

$ nc -U ~/Library/Containers/com.docker.docker/Data/debug-shell.sock

Clear the container logs

Once you know how to connect, all you have to do is pipe the command to nc to clear the log. However, since you cannot run the docker command on LinuxKit, you have to get the path to the log file by macOS.

$ echo ":> $(docker inspect CONTAINER_ID --format '{{.LogPath}}'); exit" | nc -U ~/Library/Containers/com.docker.docker/Data/debug-shell.sock

Since it is hard to do this every time, it might be better to define a shell function.

clear_docker_logs() {
 echo ":> $(docker inspect ${1} --format '{{.LogPath}}'); exit" | nc -U ~/Library/Containers/com.docker.docker/Data/debug-shell.sock
}

By running the above shell function, you can clear the log of the container with the container ID passed as an argument. Note that if you are installing netcat with brew, you cannot use nc -U and an error will occur. In that case, just run /usr/bin/nc with the absolute path.

Appendix

https://gist.github.com/BretFisher/5e1a0c7bcca4c735e716abf62afad389 says an example of serial connection with socat and screen, which may be easier to use when doing something on LinuxKit.

Modify the value of max open files for the running process

Thu, 30 Aug 2018 00:00:00 +0900

Do you know how to modify the value of “max open files” for a running process? You can modify that it is using the command “prlimit”(You can also modify more than just “max open files”).

docker-prlimit-example makes it easy to try.
Run the following commands in order to connect to the docker container where the unicorn process is running.

$ git clone https://github.com/tkuchiki/docker-prlimit-example
$ cd docker-prlimit-example
$ docker build -t prlimit .
$ docker run -d --rm prlimit
$ docker exec -it $(docker ps | grep prlimit | awk '{print $1}') bash

Let’s run ps, you can see that the unicorn process is running.

root@b83fe16b540e:/app# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 1.2 1.1 102084 23336 ? Ssl 04:03 0:00 unicorn master -c unicorn_config.rb -E development -d -l0.0.0.0:8080
root 10 0.0 0.9 102084 19436 ? Sl 04:03 0:00 unicorn worker[0] -c unicorn_config.rb -E development -d -l0.0.0.0:8080
root 13 0.0 0.9 102084 19044 ? Sl 04:03 0:00 unicorn worker[1] -c unicorn_config.rb -E development -d -l0.0.0.0:8080
root 16 4.3 0.1 18500 3348 pts/0 Ss 04:04 0:00 bash
root 27 0.0 0.1 34396 2732 pts/0 R+ 04:04 0:00 ps aux

Now, try to modify “max open files” using prlimit.
First, let’s run the following command to check the current value.

root@b83fe16b540e:/app# prlimit --pid 1
RESOURCE DESCRIPTION SOFT HARD UNITS
AS address space limit unlimited unlimited bytes
CORE max core file size 0 unlimited bytes
CPU CPU time unlimited unlimited seconds
DATA max data size unlimited unlimited bytes
FSIZE max file size unlimited unlimited bytes
LOCKS max number of file locks held unlimited unlimited locks
MEMLOCK max locked-in-memory address space 83968000 83968000 bytes
MSGQUEUE max bytes in POSIX mqueues 819200 819200 bytes
NICE max nice prio allowed to raise 0 0
NOFILE max number of open files 1048576 1048576 files
NPROC max number of processes unlimited unlimited processes
RSS max resident set size unlimited unlimited bytes
RTPRIO max real-time priority 0 0
RTTIME timeout for real-time tasks unlimited unlimited microsecs
SIGPENDING max number of pending signals 7862 7862 signals
STACK max stack size 8388608 unlimited bytes

The NOFILE line is the “max open files”.The soft limit / hard limit are both set to 1048576.
Modify the value of soft limit / hard limit to 1024.

root@b83fe16b540e:/app# prlimit --pid 1 --nofile=1024:1024
root@b83fe16b540e:/app# prlimit --pid 1
RESOURCE DESCRIPTION SOFT HARD UNITS
AS address space limit unlimited unlimited bytes
CORE max core file size 0 unlimited bytes
CPU CPU time unlimited unlimited seconds
DATA max data size unlimited unlimited bytes
FSIZE max file size unlimited unlimited bytes
LOCKS max number of file locks held unlimited unlimited locks
MEMLOCK max locked-in-memory address space 83968000 83968000 bytes
MSGQUEUE max bytes in POSIX mqueues 819200 819200 bytes
NICE max nice prio allowed to raise 0 0
NOFILE max number of open files 1024 1024 files
NPROC max number of processes unlimited unlimited processes
RSS max resident set size unlimited unlimited bytes
RTPRIO max real-time priority 0 0
RTTIME timeout for real-time tasks unlimited unlimited microsecs
SIGPENDING max number of pending signals 7862 7862 signals
STACK max stack size 8388608 unlimited bytes

You can see that the value has changed to 1024.

Forking a process like a unicorn does not affect child processes. The following command generates a prlimit command that modifies the “max open files” for both the parent and child processes.

root@b83fe16b540e:/app# PID=1; pids(){ echo $1; for p in $(ps --ppid $1 --no-heading | awk '{ print $1 }'); do echo $p; pids $p ; done ; }; pids $PID | uniq | xargs -I{} echo "prlimit --pid {} --nofile=65536:65536"
prlimit --pid 1 --nofile=65536:65536
prlimit --pid 10 --nofile=65536:65536
prlimit --pid 13 --nofile=65536:65536

PID=1 is the PID of the parent process, and PID=10,13 are the child processes. Why not just run prlimit directly? This is because prlimit has a large impact when it fails, and I think it’s better to check it before running. For example, if you mistakenly use –nofile=1:1, the process will most likely not work properly. If you only need to modify the child processes, please run the following command.

root@b83fe16b540e:/app# PID=1; pids(){ for p in $(ps --ppid $1 --no-heading | awk '{ print $1 }'); do echo $p; pids $p ; done ; }; pids $PID | xargs -I{} echo "prlimit --pid {} --nofile=65536:65536"
prlimit --pid 10 --nofile=65536:65536
prlimit --pid 13 --nofile=65536:65536

Conclusion

This article was an introduction to how to use prlimit to modify the value of “max open files”.
I hope this helps you!

Send multipart/form-data requests with Vegeta

Sat, 14 Jul 2018 00:00:00 +0900

Vegeta is an HTTP load testing tool written in Go.

When sending multipart/form-data requests in the API server benchmark, wrk requires writing lua to send the request. Vegeta could send the request easily without writing any code, so will share how to do it.

vegeta has the subcommands attack, report, and dump, with attack sending an HTTP Request. The -targets option of vegeta attack can send HTTP requests flexibly by specifying the text of the request header and request body.

The following is an example of a file to specify for -targets.

POST http://localhost:8080/api/path
Content-Type: multipart/form-data; boundary=vegetaboundary
@body.txt

@body.txt is the path to the file where the request body. You can write it as follows:

--vegetaboundary
Content-Disposition: form-data; name="file"; filename="dummy"
Content-Type: application/octet-stream
12345
--vegetaboundary--

Once the file is created, run vegeta attack.

$ vegeta attack -rate 10 -duration 60s -targets targets.txt

You can send multipart/form-data by writing the request body and request headers in text like this.
Vegeta writes the results of the attack to a file, and when you pass the data to vegeta report, it will output a report.

$ vegeta attack ... > load_test.bin
$ cat load_test.bin | vegeta report

You can run it as above.

References

Sun, 01 Jul 2018 00:00:00 +0900

WHOAMI

I am an SRE.

I ❤️ Shell Script and Go.