►
Description
k6: https://k6.io/
Blog: https://everyonecancontribute.com/post/2021-11-23-cafe-45-k6-load-performance-testing/
Twitter thread: https://twitter.com/dnsmichi/status/1463194953170014221
k6 Office Hours: How GitLab uses k6 with Grant Young: https://www.youtube.com/watch?v=YTGkq0m1bYk
Join our meetup group: https://www.meetup.com/everyonecancontribute-cafe/
Website: https://everyonecancontribute.com/
Chapters:
00:00 Introductions
8:42 k6 Introduction
14:00 OSS and cloud differences explained
17:16 Single binary and extensions
23:50 Thresholds and SLOs
31:28 k6 cloud as datasource for Grafana cloud
33:30 Prometheus remote writes
37:00 Browser testing (announced at Grafana ObservabilityCon)
47:25 k6 Operator - Load testing as code
49:10 Q&A
A
B
Yeah
sure
I
am
nicole
mendoza
vanderhuven,
I
am
a
developer
advocate
at
k6
and
a
few
months
ago
I
found
out
that
I
was
also
now
part
of
grafana
labs,
which
was
news
to
me,
but
welcome
news
before
that.
Before
I
became
a
developer
advocate,
I
I
was
a
performance
testing
consultant,
so
that's
what
I've
been
doing
for
the
last
10
or
so
years
in
australia
and
in
europe.
B
A
Sorry
yeah,
so
my
name
is
mikey.
I'm
the
one
of
the
co-founders
of
this
lovely
session,
I'm
a
senior
developer
evangelist
at
gitlab.
Previously
in
my
previous
life,
I
was
a
maintainer
of
monitoring
software,
and
so
I'm
like
I'm
looking
into
learning
cloud
native
as
a
re,
ci
cd,
obviously
a
little
bit
of
load
testing,
and
so
we
came
about
k6
and
what
is
there
and
how
can
it
help
and
it
apparently
has
a
gitlab
integration
which
I
didn't
know
about.
C
C
We
build
headlamps
for
the
automotive
industry
and
I
do
specifically
build
software
for
high
performance
computing
like
cd
engines,
cat
engines
and
raytracer,
and
so
on
and
bd
for
being
there
for
15
years
now
and
yeah
cloud
and
cloud
native
is
more
and
more
interesting
to
us.
So
load
testing.
Always
interesting,
could
remember
the
good
old
days
bombing
service
away
so
interesting
to
see
how
this
progress
in
20
years.
D
Yeah
hi
everyone.
My
name
is
philip,
I'm
a
senior
kubernetes
and
devops
engineer
at
whitetalk
at
whitehack.
We
are
specialized
in
azure,
so
we
do
azure
consulting
iws
aks
specialized.
So
we
have
customers
to
implement
or
migrate
workload
to
kubernetes,
and
that's
my
day-to-day
work,
I'm
a
father
of
two.
I
have
a
newborn
who
is
like
three
months
and
her
daughter,
she's
like
almost
free
and
I'm
interested
in
get
up,
especially
so.
D
E
F
F
G
Real
quick,
hey
my
name
is
floor.
I
join
through
my
phone
right
now.
I
am
nicole's
colleague,
I'm
a
technical
program
manager
at
k6
or
kefauna
labs.
I
guess,
and
I
love
that
you're
all
talking
about
azure.
I
literally
just
come
out
of
a
meeting
with
microsoft.
So
that's
funny
yeah.
I
heard
someone
talking
about
their
kids.
H
B
H
I
B
A
B
Okay,
let
me
just
move
this
zoom
toolbar
out
of
the
way
and
by
the
way
yes
get
lab,
we
do
have
an
integration
with
gitlab.
I
actually
had,
because
I
do
like
a
weekly
live
stream.
It's
called
k-6
office
hours
and
in
one
of
them
we
had
grant
young
who
works
at
get
lab,
and
he
I
think
he
was
the
one
that
started.
I'm
not
I'm
not
really
sure,
but
I
think
he
developed
the
integration,
so
that
was
kind
of
cool
to
to
have
him
on.
B
So
anyone
on
a
mac,
I'm
on
a
mac
too,
so
my
instructions
will
probably
work
for
you.
If
you
want
to
install
k6,
do
a
brew,
install
k6
and
it
should
install
within
seconds
because
our
engineers,
basically
all
of
the
whole
pitch
of
k6,
is
that
it's
for
engineers
by
engineers.
So
almost
everybody
in
the
company
is
an
engineer
of
some
sort.
In
fact,
our
ceo,
robin
gustafsson,
is
still
coding
and
not
just
coding,
but
he's
recently
created
a
new
feature
that
we
announced
that
maybe
I'll
talk
about
later.
B
But
this
is
like
a
a
simple
script
in
kasich's.
It
is
written
in
javascript,
scripts
are
written
in
javascript,
but
k6
itself
is
written
in
go
and
that
was
like
a
deliberate
choice
because
go
is
inherently
performant,
it's
built
for
performance,
but
we
thought
that
javascript
is
pretty
much
ubiquitous
for
testers
and
developers
like
as
a
tester.
I've
used
tools
like
selenium
and
cypress
and
playwright,
and
so
for
me
it
wasn't
as
big
a
deal
like
it's
not
like.
You
have
to
learn
some
new
thing
that
only
works
for
this
tool.
B
B
Once
you've
got
k6
installed,
you
just
do
a
k6
run
and
then
the
name
of
the
script,
and
this
is
what
you're
going
to
get
oops.
Let
me
zoom
out
a
bit
because
yeah,
the
formatting
is
a
bit
wonky
otherwise,
and
when
I
first
saw
this,
I
was
like.
Oh,
what
is
this
all
mean,
but
I
think
the
most
important
one
is
http.
Rectoration
is
what
what
people
call
response
time,
and
I
would
look
at
this
one
for
the
ones
that
it
was
successful.
B
The
average
was
730
milliseconds,
so
you
can
see
that,
even
though
I
have
just
one
request
here,
there
are
actually
two
requests
that
were
sent
and
that's
because
knowing
the
application,
I
know
that
it
does
a
3-0.
It
returns
a
301
to
redirect
it,
and
then
it
gets
to
200
just
in
case.
Anyone
was
wondering
why
there
are
two
requests
when
there's
one
here.
B
B
So
in
in
this
script,
you
still
have
the
same
http
request,
but
this
time
I'm
actually
being
a
little
smarter
about
it
and
checking
the
response
that
comes
back.
So
this
this
is.
This
line
is
checking
to
see
whether
the
response
that
was
returned
is
in
http
200,
and
this
one
checks
whether
there
is
the
word
pikachu
in
the
response,
because
this
is
like
something
that's
so
annoying,
but
I
have
come
across
applications
where
you
get
an
http
200.
B
So
if
you
were
trying
to
test
like
an
end-to-end
flow
where
a
user
logs
in
and
you
know
or
go
to
a
site
and
then
spend
some
time
to
read
what
was
on
there,
then
you
probably
want
some
sort
of
think
time
as
well.
And
that's
that's
what
I'm
doing
here
with
this
random
sleep
between
zero
and
five
still
but
better
than
the
the
first
script,
but
still
not
a
load
test
and
what
most
people
call
a
load
test
is
just
volume.
B
So
now,
instead
of
running
it
once
so
like
in
the
one
that
I
ran,
it's
just
one
iteration.
But
now
because
I'm
setting
some
options,
I
I
can
do
it
for
10
minutes
and
set
the
the
number
of
virtual
users
or
vus.
So
up
until
this
point,
like
everything,
k6
is
free.
It's
an
open
source,
free
load,
testing
tool
and
actually
it
can
do
up
to
40
000
on
one
load
generator,
which
seems
amazing.
B
I
it's
hard
to
think
of
a
scenario
where
you
wouldn't
want
to
start
putting
that
on
the
cloud
and
thinking
about
putting
it
in
different
availability
zones,
because
then
it's
just
like
the
very
dependent
on
one
machine
in
one
location,
but
it's
still
really
cool
that
it
gets
up
to
that
high,
because
I
know
a
lot
of
other
tools
don't,
and
I
also
like
that.
It's
easy
to
it's
easy
to
scale
up
so
the
the
whole
business
model
of
k6.
B
Is
that
there's
like
an
oss
tool
and
then
there's
a
sas
platform
that
takes
the
same
tool
and
puts
a
bunch
of
other
stuff
around
it
that
you
don't
need.
Not
everybody
needs
kasich's
cloud
and
you
can
certainly
do
it
yourself,
but
it
is
a
little
bit
more
set
up.
So
it's
not
it's
not
for
everybody.
If
you
do
want
to
pay
really
it's
the
same
tool
at
the
heart
of
it.
It
just
adds
like
a
few
convenience
features,
but
going
back
to
to
the
script.
B
B
Wait,
let's,
let's,
let's
take
it
one
step
at
a
time
so
like
right
now
in
the
previous
ones,
I'm
I've
just
been
requesting
pikachu.
The
problem
was
that
with
that
is
that
you
start
to
run
into
caching,
potentially
like
if
it's
being
cached
like
on
the
client
side
or
on
on
the
server
side,
then
the
response
time
that
you
get
back
may
not
really
be
indicative
of
a
new
user.
It
might
be
like
a
returning
user
and
how
often
it
depends
on
your
use
case
but
like
how
up?
B
B
So
I
didn't
know
that
there
were
that
many
of
them
anyway
now,
instead
of
just
requesting
pikachu,
it
requests
a
random
one
from
that
list
and
then
also
checks
to
make
sure
that
name
return
is
returned
in
the
response,
so
still
the
the
same.
Think
time
as
normal,
but
here's
the
exciting
part.
Now
this
is
an
extension.
B
I
should
probably
say
that,
like
with
k6,
there's
there's
a
lot
of
things
that
we
create,
that
don't
make
it
into
the
core
k6
binary,
and
that's
because
we
are
really
very
pedantic
and
very
particular
about
what
makes
it
there,
because
that's
just
going
to
bloat
up
the
the
binary
and
we
don't
want
it
to
be.
We
don't
want
to
get
to
the
point
where
it
just
has
like
every
single
possible
feature,
but
most
people
use
like
50
of
it.
B
So
the
k-6
approach
is
keep
the
core
as
like
minimalist
as
possible
as
performant
as
possible,
and
actually
we
are
our
developers
that
the
maintainers
of
of
k6
oss
still
regularly
like
remove
libraries
that
that
we,
that
are,
that
bloated
up
a
little
bit
so
but
then
the
problem
is,
if
you
make
it
so
minimalist,
then
there
are
a
lot
of
things
that
you
can't
do
right.
So
the
approach
is
to
have
extensions,
and
maybe
I
can
share
that
and
we
call
it
xk6.
B
And
it
is
a
a
way
to
to
to
create
extensions
with
k6.
Those
extensions
are
written
in,
go
and
basically
xk6
lets.
You
bundle
up
one
or
more
extensions
and
create
your
own
custom
binary
of
k6,
so
we
we
still
develop
these.
These
two
people
are
are
also
on
the
k6
team,
so
we
develop
a
lot
of
the
extensions
ourselves,
but
we've
happily
also
found
a
lot
of
contributions.
B
Externally,
too,
I
know
floor
who,
who
is
on
the
call
as
well?
She
just
did
this
hackathon
kind
of
thing
where
for
october,
sorry,
not
hackathon,
we
do
have
a
hackathon
right
now,
which
is
why
it's
on
my
mind,
but
for
hacktober
we
we
did
get
a
lot
of
external
contributors
as
well,
and
that's
really
cool,
because
people
are
using
this
beyond
the
k16.
B
People
are
making
things
and
doing
weird
things
with
it,
like.
I
think,
when
one
person
created
an
extension
for
testing
for
testing
minecraft
servers
or
something
I
I
don't
play
minecraft
myself,
but
yeah,
there's,
there's
already
a
bunch
of
different
extensions,
and
not
all
of
them
were
ones
that
we
made.
B
B
It
retrieves
the
list
of
pods
and
then
it
looks
through
it.
It
iterates
through
the
list
and
looks
for
one
with
that
starts
with
app
one
pod
that
starts
with
app,
and
then
it
terminates
that
the
cool
thing
is
that
it's
in
the
same
script
as
a
as
a
load
test.
I've
never
seen
that
before
and
it
is
super
cool
because
then
you
can
do
things
like
this,
so
I
I
have
a
couple
videos
on
this
on
how
to
do
chaos,
experiments
with
k6.
B
I
did
one
with
grafana
one
with
new
relic
and
it's
also
pokemon
themed.
Hence
the
the
get
pokemon
name
here,
but
the
cool
thing
is
that
you
can
have
different
scenarios.
So
it's
not
just
like
like
this
sort
of
script
is
very
linear.
It's
like
you
start
here
and
then
you
go
through
and
then
you
end
and
then
maybe
you
iterate,
because
this
one
has
a
duration,
but
now
we're
starting
to
look
at
separating
out
different
scenarios.
So,
right
now
I've
got
one
one
function.
B
That
does
the
the
request
for
information,
but
I
have
another
scenario
that
is
specifically
for
chaos.
Why
that's
interesting
is.
I
can
also
change
the
parameters
for
it,
so
I
can
say
that
there
are
stages
and
in
the
way
that
it's
set
up
right
now
for
the
first
minute
it
is
ramping
up
to
from
0
to
30,
because
without
those
stages
it's
like
it
goes
from
0
to
30
immediately.
But
how
often
does
that
happen?
When
30
users
happen
to
make
the
same
request
at
exactly
the
same
time?
They
don't
really
coordinate
right.
B
So
so
this
is
a
ramp
up
gradually
to
30
users.
And
then
this
is
a
steady
state.
I
mean
really.
You
would
probably
have
this
at
like
15
minutes
or
something,
and
maybe
this
is
30
or
or
an
hour.
But
you
get
the
idea,
you
can
add
as
many
stages
as
you
want
as
well
and
then
for
this
chaos,
one.
What
I'm
doing
is
I
I
don't
want
it
to
run
many
times
during
my
test.
I
just
wanted
to
run
it
once
so
now.
B
I
I
just
start
halfway
through
about
halfway
through
the
test,
and
I
just
have
it
run
one
iteration
with
one
vu
so
now
we're
talking
about
a
chaos,
experiment
and
a
load
test
that
are
both
scheduled
in
the
same
script.
Using
the
same
language
and
that's
kind
of
unheard
of,
I
haven't
seen
anything
like
that.
In
fact,
chaos
experiments
in
general.
They
usually
are
very
declarative,
so
they're
set
in
yaml-
and
I
don't
know-
maybe
it's
like
the
tester
in
me,
but
I
just
want
more
control
than
that.
B
I
want
to
be
able
to
put
it
in
loops
and
do
conditions
and
and
whatnot.
So
this
this
kind
of
chaos
experimentation
is
I
I
really
like
it.
I
think
it's
different
from
what
else
is
out
there,
and
I
also
really
like
that.
K6
is
big
on
thresholds,
so
this
one
is
checking
for
the
error
rate.
I'm
saying
that
the
error
rate
should
be
less
than
or
equal
to
five
percent
and
then
for
these
two.
B
B
You
could
call
it
slos
as
well,
but
I
think
it's
very
important
to
have
an
idea
of
what
even
constitutes
as
a
success
or
or
a
failure
in
a
test,
otherwise
you're
just
running
it
and
then
what
you're
you're
kind
of
relying
on
manual,
intervention
or
judgment
which
could
be
different
when
you
pass
it
on
to
the
next
tester
or
the
the
next
person.
That's
running
the
test
right,
so
that's
not
entirely
the
best
idea.
B
So
I
don't
want
to
run
this
and
be
too
destructive
today,
but
I
do
want
to
show
you
so
you
can
also
do
so.
I
did
k6
run
earlier,
but
you
can
also
do
a
cloud
and
because
I've
already
logged
in
what
this
is
doing
is
this
is
still
running
on
my
local
machine,
but
now,
it's
being
that
the
results
are
being
output
to
k6
cloud.
So
let
me
show
you
what
that
looks
like
this
is
k6
cloud.
B
This
thing
means
that
there's
a
test
running
and
there
it
is
so
you
can
see
that
it's
a
local
execution-
and
this
is
just
a
good
way
to
see
it
in
real
time
and
you've
got
the
requests
here,
the
thresholds
which
will
come
up
soon
when
when
they
actually
have
enough
data,
there
are
checks.
So
it
looks
like
that's
not
doing
too
well,
that's,
okay,
it's
a
it's
a
test,
app
and,
and
so
it
does
look
like
we're
getting
some.
B
Oh
okay.
I
think
that
was
just
because
it
was
it
was
starting
up.
There
were
no.
There
were
no
successes
yet,
but
we
are.
We
are
getting
the
successes.
You
can
also
do
analysis
here,
so
you
can
see
like
it's
it's
running
this.
It's
still
the
same
tool
at
the
heart
of
it.
You
can
easily
switch
between
running
locally
as
a
shakeout
or
running
on
cloud
and
there's
also
a
distributed
way
to
do
it.
You
can.
You
can
run
on
k6
cloud
itself
from
the
cli,
but
let
me
actually
try
to
do
this.
B
This
is
a
cool
feature
as
well.
I
will,
how
am
I
gonna
drop
it
in
the
chat?
Okay,
oh,
I
just
dropped
a
a
dashboard
link.
There
oh
looks
I'm
so
glad
floor
floor
is
in
chat
because
it
was
hidden
for
me
on
zoom.
Yes,
extensions
are
go,
it
is
not
node,
we
don't
use
node
and
which
means
we
also
don't
use
those
libraries.
B
D
B
B
B
I
could
just
do
k6
cloud
simple
this
time,
I'm
still
kicking
it
off
locally,
but
it's
not
it's
no
longer
running
locally,
it's
running
on
the
cloud
and
there
are
options
here.
So
I
you
know
where
I
set
this
part
this
stuff.
You
can
also
set
the
load
zones
and
in
exact
percentages,
like
you,
can
say,
20
in
frankfurt
and
20
in
sydney
that
that
kind
of
thing-
and
now
this
should
be
running
on
the
cloud.
B
B
B
So
this
is
an
example
of
where
there
was
an
error
that
slowly
accumulated.
So
this
is
is
highlighting
certain
things
I
mean,
I
guess
in
this
case
it
would
be
pretty
obvious
because,
because
it's
in
red
but
like
let's
look
at
something
else-
that's
maybe
not
as
obvious
ooh
high
low
generator
memory
is,
is
a
good
one.
That's
not
something!
That's
part
of
the
the
standard
metrics
that
most
people
would
be
looking
at.
B
So
this
is
saying
that
the
memory
usage
is
high,
and
this
is
what
happens
when
that
when,
when
the
memory
is
too
high
performance
starts
to
degrade
here's
what
you
can
do.
So
I
really
like
this
part
of
k6
cloud,
because
it's
more
than
just
like
spitting
out
the
data
right,
so
that's
cool,
but
so
k6
cloud
is,
is
definitely
useful
for
all
of
that.
But
another
way
that
you
could
do
it
if
you're,
if
you're,
wanting
to
just
pipe
your
results
out
to
grafana.
B
For
instance,
one
of
the
benefits
of
of
working
at
grafana
labs
now
is:
is
this
a
way
paved
for
all
of
those
integrations?
But
the
reality
is
a
lot
of
those
had
started
before
the
acquisition,
because
it's
just
a
lot
of
synergy.
We
had
one
person
on
the
k-6
team
who
was
already
maintaining
grafana
tempo,
so
we
were
already
using
each
other's
tools
and
we
and
that's
been
happening
for
years,
so
it
kind
of
worked
out
really
well
before
we
move
off
of
the
cloud
stuff.
B
If
you
are
using
grafana
cloud
and
k6
cloud
or
k6
cloud
in
any
grafana
instance
you
we
now
have
a
k6
cloud,
grafana
data
source
plugin,
so
you
just
install
it
and
what
it
does.
Is
it
recreates
everything
in
in
k-6
cloud.
So
once
you
install
that
you
go
to
data
sources,
which
is
this
screen
and
you
go
to
k6
cloud
and
you
will
need
an
api
token,
which
I'm
not
going
to
show
exactly
my
token.
B
But
you
go
here
and
click
on
api
token
copy
that
into
here
save
and
test,
and
then
I
also
would
recommend
that
you,
you
import
these
dashboards
at
least
as
a
base.
Just
that
way,
it's
just
less
hassle.
So
we'll
have
a
look.
So
this
is
bringing
up
all
of
the
organizations
and
all
of
the
projects
that
are
associated
with
a
k6
cloud
account.
Let's
try
and
find
the
one
that
we
just
ran.
I
B
So
this
is
the
one
that
we
stopped,
that
I
ran
just
now,
and
this
is
the
one
that's
still
running,
30
virtual
users,
so
it
pulls
in
everything,
even
the
ones
before
you
installed
the
plug-in.
So
that's
one
of
the
advantages
of
this.
You
don't
have
to
rerun
everything
it
just
scrapes
that
takes
that
data
from
k-6
cloud.
B
This
is
what
it
looks
like,
and
this
is
the
idea
is
to
recreate
the
experience
in
k6
cloud
just
on
grafana
in
case
you
already
have
a
lot
of
other
things
that
you're
monitoring
in
grafana.
It's
just
another
way
to
share
it
to
to
the
people
who
are
already
looking
at
dashboards
in
grafana.
It's
the
same
sort
of
thing
and
of
course
all
of
this
is
customizable.
B
So
the
problem
is
that
this
is
still
using
k6
cloud,
but
we
are
very
big
on
also
beefing
up
the
open
source
side
of
it
and
the
way
that
we
do,
that
is
with
prometheus
remote
right,
k6,
now
not
natively,
but
there
is
an
extension
for
for
piping
out
the
k6
load.
Testing
results
to
prometheus
remote
right.
So
let
me
show
that
as
well.
B
And
whoops,
let
me
just
change
directories
here:
yeah,
okay,
so-
and
this
is
where
I'm
going
to
expose
my
api
token-
do
not
worry,
I
will
rotate
it,
and
this
is
a
free
account.
So
not
that
important,
but
but
first
this
is
what
we're
going
to
do.
This
is
just
a
better
format,
we're
basically
putting
in
the
same
information
that
we
got
from
from
grafana.
So
let
me
show
you
so
from
a
grafana
instance.
B
B
B
Let's
see
what
that
looks
like
on
grafana
cloud,
so
not
that
one.
So
you
can
see
that
that's
already
starting
up
here.
So
again
you
could.
This
could
be.
This
will
work
with
anything
that
runs
prometheus,
not
just
grafana.
You
could
also
be
piping
it
out
to
new
relic,
for
instance,
a
lot
of
a
lot
of
people.
A
lot
of
companies
use
multiple
apms
for
a
variety
of
reasons,
so
you
can
also
do
that
there.
B
Just
do
you
have?
Is
it
any
other
questions
on
the
chat?
Just
let
me
know.
Oh
yeah
floor
is
talking
about
github
co-pilot
pilot.
It's
really
cool,
I
just
I
got
on
the
waiting
list
or
beta
or
whatever,
and
apparently
k-6
works
with
it,
not
always
perfectly,
but
it's
it's
pretty
good.
Actually,
it's
it's
pretty
surprising.
B
B
Is
it
this
one?
Okay,
so
there's
something
called
xk6
browser,
and
this
is
not
part
of
core
k6,
but
it
is
a
browser
level
testing
feature.
It
adds
a
browser
level
testing
feature
to
k6.
So
this
is
an
example
of
one
of
those
scripts.
Well,
actually,
this
is
one
where
it's
just
the
browser
level
a
caveat
before
I
I
show
you
this.
This
is
really
new
okay,
so
this
is.
This
is
just
off
the
press
and
it's
not
there's
a
reason
that
it's
not
in
quarry.
B
Yet
it
is
still
in
early
beta
I'd,
say
so
like
see
whether
you
think
whether
it
works
for
your
situation,
but
I
think
it's
already
really
cool.
The
idea
is
that
hybrid
load
testing
is
a
really
good
thing
to
do,
because
you've
got
front
end
and
back
end,
normally
protocol
level
tools
like
k6
or
jmeter
gatling
loadrunner
for
the
http
protocol.
Anyway,
those
just
test
protocol
level,
those
just
send
protocol
level
requests,
but
there's
a
lot
that
isn't
captured
by
those
types
of
of
tools.
So
there
are
browser
level
metrics.
B
That
really
arguably,
should
be
looked
at.
If
you're
looking
at
a
holistic
performance,
there
are
things
that
you
can't
just
measure
with
the
response
time
at
the
protocol
level,
when
you,
when
you
request
a
javascript,
you
are
just
downloading
that
you're,
not
it's
not
being
executed.
Client-Side,
which
is
a
problem,
could
be
a
problem
depending
on
your
application.
B
So
this
is
another
build
of
of
k6.
This
is
another
extension,
and
this
looks
very
much
like
like
a
playwright
script
and
that's
with
good
reason.
It's
because
we
have
borrowed
liberally
from
playwright
and
puppeteer.
Why
reinvent
the
wheel,
you
know
so
we're
trying
to
get
api
compatibility.
It's
it's
rough
api
compatibility
right
now,
but
there
are
a
few
things
that
it
can
already
do.
B
So
the
difference
is
that,
instead
of
sending
the
http
request
to
needing
to
know
the
underlying
message
that
is
actually
sent
by
the
browser,
you're,
just
interacting
with
the
test,
with
the
application,
the
way
a
regular
user
would
floor
saying
this
was
the
most
requested
feature
ever
yes,
and
actually,
when
I
interviewed
4k6
a
year
ago,
one
of
the
things
because
I
wanted
to
talk
about
the
direction
I
was
like.
Why
don't
you
have
some
solution
for
browser-based
testing
and
the
ceo
said
that
that
I
mean
he
had
already
heard
it
from
other
people.
B
How
cool
is
that,
like
nobody
listens
to
me
like
that?
Maybe
that
has
something
to
do
with
me,
but
anyway,
so
he's
the
one
that
that
started.
This
it's
now
been
passed
on
to
a
full
team
that
will
be
working
on
this
and
you
can
see
here
that,
instead
of
of
specifying,
like
the
the
exact
link,
it's
based
on
dom
elements
and
what's
seen
on
the
page,
so
this
is
look.
This
is
a
way.
This
is
a
selector
for
an
element
and
then
it's
you
can
just
click
on
it
and
also
get
screenshots.
B
So
maybe
I
should
show
the
page
this
is
actually
based
on.
So
this
is
just
a
test.
Oh
well!
We
we
made
this.
So
I
know
that
it's
safe,
it's
not
the
most
performant
honestly,
but
you
know
that's
okay.
Oh,
it
looks
even
uglier
than
it
normally
does.
This
is
supposed
to
be
like
a
an
e-commerce
type
thing.
Let
me
actually
do
it
with
this
browser
window.
B
So
it
is,
it
is
pretty
slow,
but
it
is
a
fake
eshop.
What
the
script
is
going
to
do
is
it's
going
to
go
to
this
page
and
it
will
select
the
first
one.
I
did
the
script
literally
like
30
minutes
ago
or
well,
30
minutes
before
this
started.
So
it
doesn't
do
that
much,
but
it
clicks
on
this.
That's
the
idea
anyway,
and
then
this
will
open
up
the
product
page
for
it
and
then
it'll
add
to
cart,
and
then
it
will
view
it.
B
B
Okay,
so
I
need
to
run
this
specific
one,
because
it's
this
is
the
the
custom
version
custom
binary
of
k6,
and
this
is
the
e-commerce
one.
So,
let's
see
so
there's
the
chromium
window,
there
is
a
way
to
run
it
headlessly,
but
I
mean
this
is
visual,
so
I
wanted
to
actually
show
you
so
then
it
should
click
on
on
that.
Okay,
that's
the
product
page
and
then
it
should
add
it
to
cart.
B
And
then
it
should
view
the
cart.
Let's
see
if
it
happens,
oh
yes,
it
is
added
and
look
view,
cart.
Okay,
so
that's
that's
where
I
ended
it,
but
the
cool
thing
is
look
at
all
these
new
metrics.
So
in
addition
to
the
other
metrics
that
that
usually
the
k6
comes
out
with
there's
now
these
cool
browser
ones
so
dom
content
loaded,
first
contentful
and
first
meaningful
paint,
first
paint
browser
loaded
and
because
we're
using
k6
for
all
of
this.
If
you
you
can
also
set
thresholds
on
these,
you
can
have
custom
metrics.
B
So
it
was
a
really
big
deal
for
us
to
to
have
both
of
them,
and
if
we-
because
I
have
these
things
here,
like
I'm,
actually
taking
screenshots,
let's
see
if
it
actually
yeah
screenshots,
it
actually
did
so.
This
is
as
it
was
running
you
can
see
like
if
you,
if
you
ever
have
an
error,
you
can
see
what
did
load
what
didn't
load.
You
know
this
added
to
cart
shows
this
album
has
been
added
to
your
cart
and
this
is
showing
it's
just
a
good
way
to
troubleshoot.
B
If
you're
not
sure
exactly
what
happened
so
now
we're
getting
to
something
that
isn't
just
load
testing
anymore.
It's
it
could
be
front
end
load
testing,
but
it
could
also
be
just
like
functional
automation.
Testing
floor
says
I
feel,
like
nicole's.
Persistence
was
with
tip
the
scale
towards
xk6
browser,
yeah
persistence.
B
I
mean
some
people
just
call
it
nagging,
but
yeah,
I'm
glad
I
did
it
because,
even
though
this
is
rough
right
now,
I
think
it
has
potential,
and
this
is
one
of
the
reasons
that
I
switched
to
well,
I
say
switch,
but
I
still
use
jmeter.
I
still
use
gatling,
like
I
think
it's
important
to
use
all
the
tools
and
and
not
just
like
get
pigeon
holed
into
one,
because
what
no
tool
is
best
in
all
situations
and
pretty
much.
B
B
Imagine
having
that
in
your
in
your
load
test
right.
Just
another
thing
that
I
do
want
to
talk
about
is
another
extension
that
I
did.
I
talked
to
one
of
the
external
contributors
for
it
actually
xk6
operator
can't
find
it.
Let's
see,
grafana
xk6
operator,
oops,
okay,
oh
it's
just
k6
operator!
Okay,
so
I
really
like
this
because
it
is
a
kubernetes
it
lets.
You
create
a
custom
resource
object
for
k6
kubernetes,
so
that
has
two
things.
B
One
is
that
you
can
manage
k6
the
same
way
you
manage
all
other
resources
you
can
set.
You
can
set
resource
limits
for
the
pod.
You
can
set
a
number
of
pods,
so
it
is
so
you
can
set
things
like
affinity
and
anti-affinity
rules,
and
it's
just
one
less
thing
that
you
need
to
worry
about,
and
you
have
a
fully
functioning
environment
with
your
application,
with
tests
that
are
scheduled
to
run
at
a
certain
time.
So
that's
one
big
benefit
of
it.
B
The
other
benefit
is
that,
of
course,
you
can
circumvent
k-6
cloud,
if
you,
if
you
use
this
extension,
which
was
started
by
someone
who
who
used
to
work
for
kasich's
but
now
has
gotten
other
contributors
to
do
it,
but
you
can
also
just
run
it
on
your
own
infrastructure,
run
k6
tests
on
your
cloud
or
or
your
data
center.
I
guess
if,
if
you
have
one
but
yeah,
this
is
what
it
would
look
like.
You
can
set
the
parallelism
here
and
the
script
as
well.
B
E
Particularly
in
terms
of
let's
see,
organizing
different
scenarios,
so
also
in
the
previous
example
with
the
api,
but
also
in
this
example,
with
with
the
webshop
most
practical
cases,
you
want
to
test
like
different
types
of
users.
You
know
a
lot
of
views
are
just
hanging
around
on
the
first
page,
just
getting
information
about
the
product,
not
so
many
ordering
in
the
end,
it
seems
to
me,
that's
not.
E
B
Yeah
you,
you
definitely
can
do
that
you
can.
You
can
have
different
javascript
files
and
just
import,
and
let
me
see,
maybe
I
can.
I
was
working
on
something
so
okay,
so
this
is.
This
is
the
main
script.
This
is
in
progress.
It
might
not
even
work
right
now,
but
I
do
have
it
broken
up
into
different
sections
so
like
this
is
the
browse
one
and
because
this
is
the
reality.
B
So
maybe
something
like
browsing
only.
You
know
something
like
that.
Oh
did
you
see
that
that's
like
that
was
that
was
good
to
pilot
anyway.
So
so,
instead
of
this,
then
I
could
say,
like
maybe
home
page
and
then
browse
something
like
that,
and
then
you
could
define
another
function
where
this
time
it's
purchasing
and
that
would
go
home
page
browse
view
product.
E
B
B
My
personal
opinion
is,
I
would
test
in
every
environment
that's
available
to
me,
so
I
think
that
that
it's
a
really
good
idea
to
test
as
early
as
possible.
The
reality
is
you're
not
always
pulled
into
that
stage.
Sometimes
you're
pulled
in
later,
so
you
test
with
the
environment
that
you're
given,
but
you
don't
use
the
same
test
so
I
like,
if
I
probably
wouldn't
be,
wouldn't
start
with
a
chaos
experiment
in
production.
B
B
B
There
are
k-6's
is
in
javascript,
because
I
mean
we
could
have
kept
it
in
go.
But
we
made
the
scripting
language
javascript
so
that
it
can.
It
is
more
developer
friendly,
and
the
idea
is
that
you
can
have
k6
scripts
and
hold
them
in
in
the
same
places
that
you're
putting
your
application
code
on
on
git
lab
or
whatever
github
that
you're
using
so
yeah
to.
B
B
B
B
A
A
B
I
haven't
seen
it-
I
am
so
failing
with
this,
but
there
it
is
yeah.
So
this
is
the
extension
that
that
you're
talking
about,
I
haven't
seen
people
using
it
with
captain,
but
this
is
also
fairly
new.
I
don't
see
why
you
couldn't
do
your
own
thing
with
quality
gates
and
everything,
because
you
can.
This
is
just
one
of
many
output
formats.
You
can
also
output
to
csv
or
json
or
junit,
or
many
many
different
formats.
A
Yeah,
the
the
reason
why
I'm
asking
is
I
like
testing
in
production,
but
I
also
like
deploying
into
a
staging
environment
from
ci
cd
pipelines
like
a
much
request,
and
then
you
do
load
performance
testing
and
you
collect
the
metrics.
You
define
your
slos,
your
service
level
objectives,
and
then
you
have
like
a
quality
gate
which
evaluates
that.
A
Like
there
are
a
lot
of
components
involved,
but
I'm
thinking
of
making
this
easier
for
like
me
as
a
developer
or
I'm
taking
the
developer
head
now,
I
don't
want
to
set
up
anything.
I
just
want
to
consume
it
where
I
can
say:
okay,
I'm
using
k6
and
grafana
cloud
or
I'm
using
something
else
and
then
tied
it
tied
it
to
my
ci,
cd
workflows
and
hopefully
maybe
it's
enabled
by
default
or
I'm
using
a
ci
include
or
whatever.
A
A
I'm
thinking
thinking
of
like,
as
you
said
earlier,
there
might
be
some
people
who
already
have
an
existing
monitoring
system
just
to
to
reuse,
what's
already
there
and
combine
it
with
ci
cd
workflows,
just
like
thinking
out
loud,
finding
different
use
cases
to
drive
more
people
into
testing,
which
is
a
good
thing.
I
wish
we
had
that
like
10
years
ago,
when
the
revi
we
were
writing
our
own
mario
scripts
with
check
custodies
or
check
whatever
for
end-to-end
testing
and
as
nice
as
these
scripts
and
add-ons
are
it's
like
the
onboarding.
A
B
B
B
B
Yeah,
so
we
are
looking
into
that.
Like
I
said
one
of
our
one
of
the
k-6
team
members,
his
name
is
danielle.
Gonzalez
lopez
he's
one
of
the
maintainers
of
grafana
tempo,
so
we've
been
thinking
about
what
what
we
can
do
on
on
that
front
as
well.
So
that's
like
the
next
frontier
I
think,
distributed
tracing.
A
A
Is
it
just
metrics
or
does
it
need
more
context
like
creating
a
trace
with
spam
or
traces
in
spans
and
adding
the
context
of
the
website
is
low
because
whatever
the
user
is
clicking
too
much
or
something
like
that
and
have
the
the
same
specification
or
the
same
format
for
everything?
So
you
just
like
fire
fire,
a
query
and
you
have.
B
A
B
A
B
B
So
this,
if
you
want
to
contribute
to
the
to
k6
core,
you
can
you
can
go
here,
but
you
can
also,
I
think,
even
internally,
when
we
try
new
features,
we
do
them
as
extensions
first,
so
probably
look
into
the
xksx
system
so
that
you
can,
you
can
have
it
as
an
option
without
needing
it
to
be
approved
and
merged
into
the
core
binary.
So
this
is
xk6.
B
E
B
B
B
I
want
to
see
stubs
like
being
able
to
to
mock
certain
things
like
a
cool
thing
that
I
think
playwright
can
already
do
where
it
intercepts
requests
and
then,
according
to
certain
conditions
and
then
returns,
a
stubbed
request,
a
response.
I
want
to
see
all
that
stuff,
but
you
know
I'm
I'm,
I'm
not
the
the
ceo.