►
From YouTube: ASP.NET Core Series: Performance Testing Techniques
Description
ASP.NET Core is a cross-platform, high-performance, open-source framework for building modern, cloud ready, connected applications.
In this episode, Ryan Nowak chats with Cecil about some tools and techniques for doing performance testing against your ASP.NET Core applications.
[01:52] - What should you really be testing?
[05:26] - Setting memory constraints
[07:45] - Collecting metrics with .NET counters
[12:22] - Load testing tool options
[15:20] - What do all these numbers mean?
[18:38] - Getting setup with the .NET counters tool
ASP.NET Core Performance Best Practices
https://docs.microsoft.com/aspnet/core/performance/performance-best-practices?WT.mc_id=ondotnet-c9-cephilli
ASP.NET Core documentation
https://docs.microsoft.com/aspnet/core?WT.mc_id=ondotnet-c9-cephilli
Create a Web API with ASP.NET Core
https://docs.microsoft.com/learn/modules/build-web-api-net-core?WT.mc_id=ondotnet-c9-cephilli
Bombardier
https://github.com/codesenberg/bombardier
dotnet counters
https://docs.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-counters?WT.mc_id=ondotnet-c9-cephilli
A
Welcome
everyone
to
another
episode
of
the
our
nature
and
we're
continuing
our
series
as
we
dive
in
a
little
bit
deeper
into
the
world
of
espionage
horn,
asp.net,
core
3,
now
I've
always
been
really
curious
about
like
performance
testing
like
how
do
I
do
it,
how
can
I
do
it
on
my
machine?
You
know
like
what
are
some
good
practices
that
I
could
use
and
tools
that
I
could
take
a
look
at
and
so
Ryan
I'm.
A
B
B
Some
kind
of
guidelines
for,
like
you
know
how
should
you
think
about
doing
per
Festing
of
an
app
versus
a
framework
because
I
know
I,
like
on
the
asp
net
core
team.
We
talk
a
lot
about
performance
like
there's,
yeah
blog
posts,
we
publish
about,
like
oh
we're,
doing,
50
million
requests
per
second
or
top
ten
for
this
benchmark,
or
you
know
list
ad
got
fifteen
picoseconds
faster
in
this
release
and
so
on.
B
B
So
with
this
application
using
ratchet
codes,
so
I'm
using
endpoint
routing
here,
an
HTTP,
client
and
I'm,
making
a
call
to
another
service,
so
I
have
two
services
here:
I
have
my
forecast
service
and
my
weather
service
and
they're
pretty
simple,
but
my
weather
service
is
going
to
get
some
Jason
from
the
forecast
service.
It's
gonna
then
incorporate
that
into
this
weather
report
and
it's
going
to
send
that
out.
So
it
just
says
like
hey
the
weather's
cloudy
in
Seattle.
B
Basically
now
my
forecast
app
is
a
little
bit
interesting
and
it's
it's
like
I'm,
really
interested
in
testing
the
weather
app
here,
not
the
forecast
app.
My
forecast
app
actually
has
a
delay
in
it.
So
it's
going
to
respond
with
some
hard
coded
Jason,
but
it's
also
got
a
delay
in
it.
Now.
Why
would
I
have
a
delay
in
an
app
like
this
like?
Why
would
I
do
that?
To
myself?
I,
obviously,
wouldn't
do
that
in
production
code.
B
Well,
the
answer
is
to
try
and
replicate
some
of
the
conditions
that
you
might
have
in
real
production
services,
so,
for
instance
like
if
I'm
just
doing
perf,
testing
and
I'm
doing
calls
from
one
service
to
another
online
machine.
It's
not
actually
a
realistic
scenario
if
they're
not
going
to
be
deployed
that
way
in
production,
because
you're
gonna
have
some
latency
and
you're
gonna
have
some
overhead
of
doing
those
kind
of
Network
calls
that
aren't
going
to
happen
without
that
being
present
on
your
own
machine,
because
they're
just
sitting
right
next
to
each
other.
B
So
one
of
the
sort
of
takeaways
from
doing
this
kind
of
easy
performance
testing
is
you're
you're,
fundamentally
in
a
little
bit
of
a
tricky
situation,
trying
to
do
all
this
testing
on
one
machine,
the
kinds
of
things
that
you
want
to
be
concerned
about
are
like.
Can
I
set
up
an
actual
database
that
I
want
to
talk
to
my
perf
tests?
B
Can
I
set
up
my
actual
dependencies
of
other
things
that
my
service
needs
to
call
into,
or
my
web
app
needs
to
fall
into
for
doing
perf
testing,
because,
if
you're
not
using
your
real
dependencies
under
your
real
networking
conditions,
things
are
always
going
to
be
a
little
bit
artificial.
The
other
thing
that
I
would
say
about
it
is
you
want
to
control
for
the
effect
of
running
a
client
and
running
multiple
things
on
your
machine?
B
If
that's
what
you're
doing
so
in
this
case,
one
of
the
things
that
I'm
doing
is
I've
actually
restricted
both
of
these
services
using
docker
I'm
using
docker
composed
to
run
stuff
and
I've,
told
docker
to
restrict
the
amount
of
CPU
time
available
and
the
amount
of
memory
available
to
both
of
these
services.
Now.
B
The
reason
why
I
might
do
that
is
I
might
do
that,
one
to
get
closer
to
my
actual
production
conditions,
so,
like
let's
say,
I'm
deployed
in
app
service
like
my
developer,
workstation
is
actually
probably
more
powerful
than
what
I
might
have
if
I'm
deployed
to
like
a
simple
app
service
instance.
The
other
reason
is
to
avoid
competition
between.
B
I'm,
basically
test
I'm,
basically
trying
to
estimate
or
trying
to
think
about
how
much
traffic
would
my
real
application
mean
to
actually
serve
and
can
we
can
we
pump
amount
of
traffic
through
with
a
load,
testing,
client
that
looks
like
what
my
site
is
going
to
need
to
serve
in
production
and
then,
if
I
do,
that
are
the
outcomes
reasonable
is?
Is
the
outcome
reasonable
if
I
do,
that
is
the
latency
good?
Is
it
crashing?
Are
there
errors?
Are
things
getting
queued?
Those
kind
of
things
what's.
A
Good
about
what
you're,
showing
here
too,
is
you
know,
even
though
we're
specifically
talking
about
low
testing
and
performance
testing
and
that
types
of
stuff.
It's
probably
just
a
good
idea
to
have
these
types
of
defaults
inside
of
your
docker
compose
files
in
general,
because
a
lot
of
the
times
when
we
show
demos
or
even
look
at
sample
quarter
even
documentation,
I
almost
never
see
anybody
specify
this
type
of
information
in
their
sample
and
I'm
sure.
A
A
lot
of
folks
that
are
watching,
probably
like
hey
I'd,
even
know
you
could
do
that
so
so
I
mean
one
yeah
sure
it's
good
for
us
to
simulate
what
production
looks
like,
but
probably
it's
a
good
idea
to
just
have
these
types
of
constraints
in
production
so
that
you
know
you
can
have
you
know
better
control
over
the
resources
that
your
containers
are
using.
Yeah.
B
The
other
thing,
the
other
thing
that
I
would
say
too
is
it-
can
give
you
and
like.
Obviously,
it's
not
total
apples
to
apples,
but
it
can
give
you
an
intuitive
sense
of
what
resources.
Does
your
application
actually
need?
I
mean
am
I
deploying
stuff
in
an
environment
like
kubernetes,
where,
like
it
really
is
a
best
practice
to
set
these
kind
of
limits
or
you
might
be
deploying
stuff
somewhere
like
app
service?
Where,
like
you,
don't
really,
you
don't
really
determine
the
limits
like
the
system
determines
limits,
but
it
can
help.
B
Writing
really
simple
apps,
but
I've
gotten
a
lot
of
performance
out
of
these
kind
of
applications
in
the
in
the
50
200
megabyte
range
dotnet,
as
of
a
spinet
core
3
or
done
in
core
3,
is
aware
of
these
settings
so
when
you're
running
inside
of
a
container
or
when
you're
running
inside
of
linux,
this
is
just
a
linux
feature
but
happens
to
be
used.
A
lot
with
containers,
the
runtime
actually
knows
what
limitations
it
has
and
adjusts
its
behavior,
based
on
what
they're
set
to
thanks.
B
So
I've
got
this
set
up
here
and
I've
already
got
some
things
running.
So
some
of
the
stuff
that
I've
got
set
up.
That's
part
of
my
perfect
esting
set
up
here
is
I've
already
launched
these
things
in
docker
compose
and
the
app
that
I'm
testing
is
listening
on
port
5,000
and
then
the
other
thing
here
is
I've
got
dotnet
counters
running
inside
my
container,
so
I'm
gonna
kill
this
and
I'm
just
gonna
show
the
command.
B
I'm
gonna
show
the
command,
so
people
can
see
it,
but
basically
what
I'm
doing
here
is
I've
put
a
label
on
my
container
I'm
asking
docker
find
me
the
running
weather
container
and
then
inside
of
that
or
outside
of
that
I'm
shelling
into
that
container
and
I'm
gonna
run
the
dotnet
counters
process.
Here,
I
can
hard
code
the
process
ID
of
one,
because
it's
in
docker,
but
basically
I'm,
just
I'm
chaining,
together
a
couple
things
that
exist
so
that
I
can
get
sort
of
like
perf
counters.
For
this
running
app.
B
If
you
use
perf
counters
on
windows
before
donna
counters
is
really
similar
to
that,
and
it's
a
command-line
tool
that
donna
t-bill,
that
you
can
use
to
do
this
kind
of
work,
so
I'm
gonna
go
ahead
and
run
something,
and
while
this
is
running,
we
can
talk
about
some
of
the
counters
and
then
I'll
talk
about
the
command
that
I'm
running
in
the
tool
that
I'm
using
too
so
I've
got.
Two
groups
of
counters
over
here.
I've
got
the
counters
that
come
from
asp
net.
That's
this
top
one,
and
we
don't
have
that
many
today.
B
This
is
a
set
that
we're
gonna
look
to
sort
of
increase
in
the
future
and
you
can
see
the
number
of
failed
requests.
The
number
this
is
a
total
like
incrementing
counter.
So
what
were
the
number
of
failed
requests
for
the
lifetime
of
the
process?
You
can
see
the
rate
of
requests.
How
many
requests
per
second
am
I
handling
and
then
how
many
current
requests?
Basically,
how
many
requests
are
in
flight
right
now,
and
there
was
one
now
there's
zero,
so
there's
not
a
lot
of
traffic
being
handled
concurrently
by
the
site.
B
There's
a
lot
of
requests
per
second
coming
through,
but
they're
being
served
for
you
pretty
quickly.
I've
also
got
a
bunch
of
counters
here,
related
to
the
garbage
collection,
so
I
can
see
the
size
of
the
GC
heap,
the
number
of
garbage
collections
that
have
happened
and
then
a
bunch
of
the
cool,
threading
and
timer
related
stuff
which
we'll
get
to
talk
about
a
little
bit
more
later.
The
other
thing
that
I
would
highlight
here
is
this
working
set.
B
So
working
set
is
just
one
of
the
kinds
of
measurements
of
how
much
memory
you're
using
we
talked
about
memory
limits.
This
container
has
500
megabyte
512
megabytes
of
memory
available,
but
we're
only
using
82.
So
then,
let's,
let's
break
down
this
command.
That
I'm
using
here
I'm
using
a
tool
called
Bombardier,
which
we
can
put
a
link
to
in
the
show
notes.
But
Bardia
is
a
cross-platform
command-line
tool
for
doing
load
testing
so
I
like
Bombardier.
B
For
a
couple
of
reasons,
there
are
a
lot
of
good
tools
out
there
I
like
Bombardier,
for
a
few
reasons.
First
of
all,
it's
modern
it's
built
on
a
lot
of
modern
tech,
so
it
just
generally
works
pretty
well
and
it's
up
to
date
with
with
standards
and
things
like
that,
it's
very
tunable,
and
it
has
lots
of
features
that
you'll
want.
So
this
L
here
that
I'm
highlighting
this
will
output
a
latency
distribution.
So
I
can
see
what
was
the
latency
average.
What
was
the
standard
deviation
and
then
what
are?
B
What
are
all
the
various
p
values
for
latency,
very
important?
If
you're
doing
this
kind
of
testing,
you
probably
shouldn't
shoot
for,
what's
the
max
throughput
I
could
do
you
should
probably
shoot
for
understanding
how
much
throughput
you
do
need
to
handle?
And
am
I
healthy
at
that
level
of
throughput?
Is
my
latency
distribution
good
or
are
things
going
into
the
weeds?
It
also
very
clearly
visualizes
what
status
codes
each
request
fell
into,
so
you
can
see.
I
had
no
Aris
400
and
500
s
would
be
errors.
B
You
know,
I
had
errors,
everything
was
a
happy
200
and
then,
as
well
bring
back
my
rate.
You
can
rate
limit
Bombardier,
which
is
super
useful
and
probably
probably
some
place.
You
should
start
is
try
to
estimate
how
much
traffic
you
actually
need
to
serve
and
then
serve
that
much
traffic,
so
if
I
want
to
serve
500
requests
per
second
I
can
do
that
with
bombardier.
The
C
by
the
way,
is
the
number
of
connections.
What
I
typically
like
to
do
with.
That
is
pick
a
pick,
a
somewhat
high
value
like
128
or
64.
B
Those
are
generally
good
values
and
you're
not
going
to
have
to
do
too
much
tuning
of
that.
So,
while
this
is
running
you
can
see,
you
know,
my
requests
per
second
is
around
500.
It's
gonna
blip
around
500
a
little
bit.
You
can
see
that
my
garbage
garbage
collections
are
happening.
My
heap
size
is
fluctuating,
and
my
CPU
usage
is
up
at
about
6%,
so
I'm,
really
not
making
very
much
usage
of
the
CPU
in
this
application
right
and
everything.
B
A
Actually,
like
kind
of
just
really
interested
in
this
bombarda
to
like
in
the
past,
I've
used
some
other
tools
like
artillery
and,
like
some
other
types
of
things,
so
I,
really
like
the
fact
that
you
could
specify
the
rate,
because
I
think
I
think
that
one
option
right
like
makes
a
huge
difference.
You
know,
rather
than
just
like
completely
hammering
my
site
with
like
how
much
ever
CPU
I
could
throw
at
it
right.
B
A
B
I'm
not
I'm,
not
familiar
with
artillery,
which
is
the
other
tool
that
you
mentioned
there.
Bombardier
is
a
good
one
to
use
as
a
starter.
If
you're
new
to
this
area,
because
again
it's
cross-platform,
it's
pretty
flexible
and
it's
pretty
beginner
friendly.
There
are
their
sets
of
tools
out
there.
That
I
would
say
fall
into
a
different
category
tools
like
jmeter,
so
a
tool
like
Bombardier
or
work,
or
you
might
be
familiar
with
Apache
bench.
A
B
Pretty
much
allow
you
to
do
like
one
request
over
and
over
and
over
again,
if
you
find
that
you
need
to
simulate
like
a
workflow
that
a
user
goes
into,
and
this
can
get
really
complex,
you
can
go
really
far
with
it.
But
if
you
want
to
actually
test
like
an
interaction
that
a
user
might
do,
you
can
either
do
custom
scripts
for
that
or
you
can
use
a
tool
like
jmeter,
which
is
one
that
I've
seen
used
inside
Microsoft
for
proof,
testing
of
stuff
I
think
there
are
some
others.
B
B
B
Http
1:1
it
supports
HTTP,
100,
and
so,
as
a
result,
it
doesn't
reuse
connections
in
the
same
way
that
an
HTTP,
1,
1
or
H
2,
B,
2,
client
would,
and
so
it's
as
a
result,
you're
gonna
get
like
much
worse,
perfect
data
from
a
B,
and
it's
not
super
realistic.
If
you
think
about
things
like
how
backends
communicate
with
each
other,
your
back
services
are
gonna,
have
long
live
connections
to
each
other,
so
avoid
a
be
use.
Something
more
modern.
Now.
A
That
got
it
all
right
cool!
That's
that's
good
information!
So
now,
after
I've
had
this
information
like
after
I've
done
this
testing-
and
you
know,
have
my
container
set
up
I
have
my
you
know:
sensible
resources,
limitations
and
things
of
that
nature
and
have
these
numbers
right,
because
I
think
another
step.
Two
is
a
lot
of
folks
are
like
okay,
I'm,
just
gonna
hammer
this,
where
I'm
gonna
run
these
perfect
eyes
and
I'm
gonna
get
some
numbers.
You
know,
I
mean
if
we're
looking
at
the
top
right
of
your
screen.
A
B
I'll
just
run
it
again
and
we're
doing
500
requests
per
second,
but
my
CPU
usage
is
actually
low
like
this
could
go
up
to
100
because
I've,
given
this
I've,
given
this
container
one
CPU
to
work
with,
but
it's
actually
hanging
around
seven
or
eight.
And
what
that
tells
me
is
that
the
work
that
this
application
is
doing
is
not
so
much
in
processing
information
as
much
as
it
is
in
like
doing
I/o
talking
to
other
resources,
which
is
true
right,
because
we're
making
an
HTTP
client
call.
B
So
you
can
learn
from
this,
because
you
can
ask
yourself
like
what
do
I
expect.
I
know
that
this
workload
makes
an
HTTP
call
and
I
know
that
that
HTTP
call
is
going
to
take
some
time
to
complete.
So
if
the
CPU
usage
was
high
instead
of
low,
that
would
probably
be
something
I'd
want
to
look
into
like
if
this
number
were
95
or
99
yeah.
A
B
B
How
you
can
use
these
kind
of
things,
I
think
the
most
important
number
for
people
is
probably
the
CPUs
usage.
Is
it
high?
Is
it
low?
What
do
you
expect,
as
well
as
the
latency
like
if
the
latency
is
longer
than
what
you
expect?
You
probably
want
to
start
using
profilers
or
other
tools
to
understand?
B
You
know
I
learned
sequel
20
years
ago
and
I
kind
of
know
how
to
do
it,
like
some
of
the
most
common
problems
that
you're
gonna
encounter
are
gonna,
be
database
related
much
more
so
than
your
c-sharp
code,
not
that
databases
are
bad
but
like
that
I
would
start
your
investigation
with
things
that
are
interesting
or
have
complicated
queries
or
have
queries
that
are
going
to
process
a
lot
of
data.
You
know
your
application
I,
don't
so
I
can't
give
you
one-size-fits-all
guidance.
Sure.
A
Sure
awesome
man
well
hey
Ryan
again,
like
you
bless
this,
it's
so
much
good
information,
but
I
really
appreciate
you
coming
on.
We
need
to
make
sure
that
we
add
like
a
lot
of
these
tools
and
services
and
stuff
like
that,
that
you
show
us
into
the
into
the
show
notes,
so
folks
can
definitely
check
it
out
well,
but
take
me
to
the
dotnet
counters
thing
I
believe
is
that
is
that
just
a
part
of
the.net
CLI
today
or
is
that
something
that
we
have
to
like?
B
Donna
counters
is
a
don''t
tool
that
you
can
install
with
the
donna
sdk.
It's
not
built
into
the
done
at
sdk
right
now.
I
think,
because
we
just
Rev
it
a
little
bit
faster
than
the
donna
sdk,
and
I
think
we
wanted
to
make
it
available
before
we
wanted
to
make
it
available
at
a
time
that
it
didn't
clearly
aligned
with
a
dotnet
SDK
release.
So
how
I'm
getting
that
and
how
I'm
doing
that
in
docker?
Is
I've
done
a
couple
things
here?
B
I've
made
a
few
small
changes
to
make
this
different
from
what
you
would
do
with
a
normal
docker
container
like
a
normal
scaffold,
the
docker
container
image
or
something
so
the
main
change
that
I'm
making
here
is
normally.
I
would
use
like
the
dotnet
runtime
image
here,
or
the
asp
net
core
runtime
image,
I'm
actually
using
the
sdk
image.
The
reason
why
I'm
doing
that
is
the
SDK
is
necessary
to
install
down
in
tools.
So
this
is
a
useful
thing
that
you
might
want
to
do
in
development.
B
It's
going
to
result
in
a
bigger
image
if
you
use
this
in
production.
The
other
thing
that
I'm
doing
here
is
I'm
actually
installing
the
tool
I'm
doing
something
bad
and
I'm
running
his
route,
which
he
probably
shouldn't
do
in
production,
but
I'm,
creating
a
folder
for
tools,
I'm,
adding
this
to
the
path
and
then
I'm
running
dotnet
tool
install
here
now.
B
One
improvement
that
the
team
is
looking
to
make
in
the
future
and
I'm
not
sure
if
it
will
be
available
at
the
time
that
this
video
is
out
or
not
so
I
apologize
for
that
we
are
looking
to
make
there
be
just
downloadable
versions
of
these
of
these
tools.
So,
rather
than
doing
this
sort
of
dance
with,
like,
let's
add
the
SDK,
let's
add
this
tool.
Let's
add
things
to
the
path.
There
will
just
be
a
single
binary
that
you'll
be
able
to
copy
into
a
container.
A
It
awesome
well
again,
hey
Ryan,
thank
you!
So
much
for
being
on
the
show
we
gotta
have
you
come
back
out
and
again
sometimes
a
share
some
more.
So
what
are
these
cool
tips
and
tricks
about
asp.net
core
sometime
in
the
future?
Yeah
it'd
be
great.
So
thank
you
all
for
watching.
This
has
been
another
episode
of
the
all
net
show
we
learned
a
little
bit
about
how
we
can
do
some
performance
testing
on
our
own
machines,
using
some
tools,
some
command-line
tools
and
some
stuff
that
the
team's
created
for
us.