►
From YouTube: Keptn and k6 integration WG meeting - June 16, 2021
A
B
Yeah,
hey
so
yeah,
I
will
just
quickly
show
how
basically
we
are
able
to
run
k6
performance
testing
using
the
job
executor
service
of
captain.
So
basically,
basically
I
have
created
a
basically.
I
have
created
two
different
two
different
services
of
captain
and
one
is
for
a
passing
threshold,
for
which
I
have
kept
a
p95
request,
duration
to
be
less
than
equal
to
to
be
less
than
500
milliseconds.
B
So
what
will
happen
on
triggering
on
triggering
the
event
of
whenever
this
event
of
remote
passing
trust
is
triggered,
so
the
job
executor
service
will
be
subscribed
to
this
event
and
it
will
catch
that
event
and
run
the
run.
The
task
run
this
service
and
the
same
goes
for
the
k6
failing
task
so
over
here
I
have
just
limited
this
p95
duration
to
one.
B
So
we
can
mimic
the
behavior
of
what
will
happen
when
this
threshold
is
failed
and
how
will
how
how
the
user,
how
the
user
can
see
the
output
so
yeah?
I
will
quickly
go
over
to
this
staging
and
try
to
try
to
run
first
the
failed
one
over
here
so
yeah,
basically
on
for
giving
the
services
and
the
stage
sequence,
we
can
trigger
the
service
yeah.
B
Oh
yeah,
okay
yeah,
so
basically
we
have
the
logs
of
k6
over
here.
So
basically,
k6
has
run
the
performance
test
on
this
on
the
base
using
this
javascript
file,
which
we
mentioned
and
over
here,
this
request.
Duration
has
been
failed.
So
that's
why
the
whole
service
has
failed
and
the
response
that
job
executor
will
give
back
to
the
captain
will
be
of
the
failed
state
and
the
same
way
it
goes
for
the
captain
for
the
k6
pass
service.
B
A
So
while
we
wait
for
that
a
bit
of
troubleshooting,
if
anyone
ever
sees
that
spinner
but
doesn't
get
a
started
event,
what
it
basically
means
is
captain
has
distributed
the
triggered
event,
but
there
is
no
service
listening
for
that
event
to
actually
action
the
event.
It's
called
me
out
a
few
times.
B
Yeah
yeah,
okay,
so
basically
this
has
been
passed
because
both
the
thresholds
of
the
of
k6
have
been
passed.
So
this
p95
is
100.9
109
milliseconds,
so
it's
less
than
500.
So
that's
why
it
exited
with
a
zero
zero
code.
So
that's
why
it's
in
green
state,
so
basically
after
the
the
so
the
pipeline
can
move
to
the
next
stages.
B
C
B
Yeah,
so
basically,
what
the
user
needs
to
do
is
that
user
can
provide
a
docker
image
corresponding
to
this.
So
we
are
using
this
load
impact
k6
image,
which
is
probably
the
official
image
of
doc
official
docker
image
of
k68
and
after
that
user
just
have
to
use
this
command
and
pass
in
the
arguments
and
put
the
files
in
the
designated
location
that
user
has
given
for
the
service
and
yeah
user
can
basically
run
the
performance
testing.
C
B
B
B
A
For
anyone
else
watching
after
this,
the
only
thing
to
note
here
is
on
line.
9
you've
got
files,
k6
pass
files,
that's
the
path
in
the
upstream
git
repo.
When
what
happens,
the
job
executor
creates
a
job,
creates
the
container
and
it
copies
those
files
into
the
container,
but
it
puts
them
under
the
captain
folder.
So
whatever
you've
got
online
nine
needs
the
slash
captain,
slash
blah.
B
C
C
B
Yeah,
you
can
do
that
also
or
so.
Basically
is
there
a?
Is
there
a
functionality
of
running
k6
inside
a
folder?
If
I
pass
just
this
and
okay,
so
it
will
not
yeah
yeah
so
far,
then
then
we
will
have
to
create
a
different
commands
for
this
yeah
or
adam.
Can
we
add
multiple
commands
in
the
same
service.
A
A
You
basically
need
to
create
multiple
tasks
in
your
ship,
because
obviously
this
is
just
your
test,
but
in
reality
this
task,
this
remote
passing
task,
will
be
part
of
a
larger
sequence
of
things
that
we
do.
We
we
might
do
a
deployment.
We
do
a
test,
we
do
a
validation
whatever
so
yeah
you
just
have
on
line
14.
There
you'd
add
a
line
15,
and
that
would
be
your
second
task.
B
B
A
C
So
I
think
we,
it
may
be
good
that
we
check
how
it
could
be.
This
example,
just
maybe
okay.
This
is
an
example
with
one
tag.
This
is
example.
If
you
want
to
create
two
tests,
I
right
now.
I
know
that
you
know
the
solution,
but
it's
not
very
clear
for
me.
How
would
be
the
configuration,
so
it
may
be
useful
if
we
also
provide
the
extrusion
if
you
want
to
run
two
basic
tests
in
a
sequence.
That
would
be
how
you
would
do
that.
A
B
C
A
C
C
A
A
No,
it's
it's
been.
It's
been
not
really
it's
been
slightly
misused
here.
I
I
get
why
you've
done
it
for
testing
purposes
to
split
it
out,
but
in
reality
what
you'd
have,
if
you
could
just
flick
back
to
your
shipyard
file.
For
me,
what
you've
done
here
is
you've
got
a
stage
called
production
which
is
fantastic
and
then
you've
got
two
sequences,
k6
pass
sequence
and
k6
fail
sequence.
Obviously
that
was
for
you
testing
things
you
want
to.
You
want
to
be
able
to
do
that
in
reality.
A
What
you'd
have
is
one
sequence,
let's
call
it
your
deploy
sequence
and
then
your
task
you'd
only
have
one
task
that
would
be
called
test.
For
example,
now
the
service
is
actually
it
models,
a
microservice
in
captain's
world,
so
you've
kind
of
used
a
service
you've
done
it
twice,
because
sequences
can
span
services,
but
so
you're
right
pepe.
It
needs
this
needs
a
bit
of
reorganization
but
effectively
what
you,
what
you
should
do
is
have
a
micro
service
that
you
want
to
test.
B
A
C
I
am
used
to
the
sequence
term
because
it
look
for
me
that
there
is
several
steps
and
a
sequence
is
just
one
step
on.
Oh,
it's,
a
sequence
on
pipeline,
so
sequence
made
totally
sense
for
me
because
I
under
I
got
in
this
picture
when
it
comes
like
okay,
it's
a
k6
series.
Okay,
I
could
get
the
point
that
I
don't
know
exactly
how
captain
works
internally
and
I
was
more
thinking
from
the
ci
perspective.
There
is
a
sequence,
a
step
that
needs
to
be
executed.
B
B
Okay,
so
yeah
coming
to
the
next
topic,
so
the
next
topic
was
regarding
the
discussion
that
me
and
adam
had
of
using
the
of
how
we
will
incorporate
kasich
extensions
to
the
to
captain.
Basically
so
yeah
yeah
I'll
again
share
my
screen
only
for
that
so
yeah
so
over
here.
What
we
need
is
that
we
need
a
docker
image
right
for
making
this
execu
executable
and
that
then
the
user
will
be
adding
something
like
I
mean
anything
over
here
right.
So
what?
Instead
of
that,
what
we
thought.
B
Basically,
this
is
using
the
job
executor
service
of
captain,
and
what
we
thought
is
that
if
we
can
write
a
different
service
for
k6,
what
it
will
do,
it
will
basically
what
we
can
do.
We
can
ask
the
users
to
keep
so
basically,
each
and
every
k6
extension
will
have
a
separate
k6
binary
of
its
own
right.
B
B
You
can
find
the
k6
javascript
file
thread
so
the
same
way,
we'll
ask
for
the
k6
extensions
file
structure
that
in
this
path
there
is
this,
so
basically
keeping
one
keeping
one
path
for
keeping
one
path
for
k6
and
in
the
prometheus
folder
there
will
be
a
k6
binary
or
there
will
be
an
influx
for
influx
db.
Folder.
There
will
be
a
k6
binary,
so
basically
asking
the
user
for
file
structure
of
k6
extension,
also,
which
the
user
wants
to
add,
use.
B
Basically
and
user,
will
keep
that
binaries
at
that
place
and
after
that,
for
for
basically
the
running
command,
the
adding
the
options
of
k6,
prometheus,
url
or
remote
url,
or
it
can
be
anything
it
can
be
influx
dp
organization
or
anything.
We
will
have
a
same
different.
Basically
in
the
config
file
in
the
yaml
file
itself
of
the
user,
he
will
add
the
he
will
add
the
values
of
this
options
that
he
want
to
use
corresponding
to
which,
whichever
k6
extension,
he
is
using
right.
C
C
B
C
Cut
last
time
there
will
be
always
we
need
to
give
the
flexibility
to
the
user,
because,
right
now
we
have
50
extensions,
sometimes
are
for
testing
protocol,
so
we
cannot
pack,
all
the
extensions
for
the
user
or
providing
so
and
the
extension
will
grow.
So
it
will
come
always
a
user
who
want
to
use
any
extension,
maybe
one
even
build
by
themselves.
In
that
regard,
we
have
two
options.
We
could
say
to
the
user.
Look
it's
very
easy.
C
C
The
problem
with
this
solution
is
like
they
need
to
do
some
preparation,
so
they
need
to
have
a
docker
account
push
into
docker.
Not
maybe
everyone
has
that,
but
it's
totally
fine,
so
you
want
to
use
like
any
type
of
thing.
So
you
need
to
add
this
configuration.
Probably
it
will
fit
to
a
lot
of
people.
C
B
B
Yeah
yeah
yeah
yeah,
so
basically
this
only
right
so
using
this
x,
yes,
the
xk6
build
that
will
be
a
k6
binary
right.
So
what
we
thought
of
the
structure
is
that
a
user
is
already
giving
this
file
structure
of
cases
executables.
I
mean
k6
website,
so
that
user
will
already.
So
this
is
a
different
service
other
than
java
job
executor
service,
which
is
directly
taking
a
docker
image
and
running
command.
On
top
of
that.
B
B
Otherwise,
if
the
user
gives
some
file
structure
of
k6
extension
that
follow
this
path
of
prometheus
and
get
the
binary
from
there,
so
that
user
can
provide
so
that
will
be
extensible
to
any
of
the
extensions
right,
because
user
will
already
be
doing
this,
I
mean
user
will
already
be
creating
this
binaries
right
using
this
xk6
build
command
right,
so
that
user
will
provide
and
then
corresponding
options.
I
mean
the
flexibility
of
providing,
which
are
options
that
you
want.
C
B
B
Can
we
add
them
just
a
while
thought
over
here?
Can
we
do
this
kind
of
structure
also
that
we
have
a
list
of
extensions
of
our
own
and
some
list
of
extensions?
And
after
that,
let's
say
prometheus
and
influx
db,
and
all
that
and
in
the
installation
of
k6
service
itself,
download
all
this
k6
binaries
and
or
would
that
be
an
overkill.
A
A
Side,
whereas
if
we
just
point
to
the
k6
docs
and
say,
go
build
your
image.
However,
you
want
to
build
it,
because,
if
k6
do
something
cool
and
wonderful
you've
got
got
to
then
redevelop
that
extension,
whereas,
if
we're
just
being
a
bit
more
hands-off,
I
don't
know,
I
mean
there's
pluses
and
minuses
to
all
of
this.
It's
it's
up
to
you,
really
how
you
want
to
solution
this.
B
C
B
C
Not
gonna
scale,
so
I'm
gonna
show
you.
If
you
don't
mind,
let
me
share
the
screen,
because
that
is
a
I
find
that
it
could
be
easily.
So
if
we
want
flexibility
share
a
screen
if
we
want
flexibility,
so
we
are
doing
this
setup
like
that,
we
say
the
user
look.
You
could
have
multiple
extension
so
start
picking
up.
C
C
So
you
could
do
something
like
this
version,
so
you
don't
need
you.
Don't
we
don't
need
to
force
the
users
to
have
the
local
extension
they
could
build?
The
extension
like
I
want
a
casic
bill,
a
k6
browser
version,
whatever
they
are
gonna
pick
up
from
the
github
report
version
two
version:
three.
We
could
let
the
user
pack
four
different
extensions,
five
different
extensions.
They
will
be
fetched
from
github
directly,
so
with
this
we
just
avoid
them
to
have
to
use
a
local
extension
that
it
is
not
very
common.
C
It's
common
to
use
a
local
extension
when
you
are
developing
your
extension,
but
once
your
station
is
ready,
then
you
make
it
public
and
you
give
the
user
those
instructions.
Look.
Do
you
want
to
use
my
extension
aka
build
the
name
of
my
extension,
nothing,
nothing
more!
So
we
we
could
have
the
two
options
like
build
your
own
docker
image.
This
is
the
extrusion.
C
B
C
Image
and
then
we
are
just
doing
going
stars
ak6,
that's
installed
ak6
and
is
building
with
any
version
that
we
have
so
we
will
just
say
to
the
user.
Okay,
if
you
want
to
run
with
extension,
either
build
your
own
docker
or
follow
this
extraction
instruction,
and
then
we
we,
we
give
entire
flexibility,
any
extension
that
you
want.
You
could
have
packed
two
different
or
four
different
extensions,
any
version
that
you
want.
So
there
is
no
any
maintenance
in
our
site.
More
than
explaining
the
extension,
as
you
did
on
the
on
the
other
integration.
B
A
C
A
C
It's
very
common
flow
because
more
of
the
cd
tool
allow
to
use
docker,
as
you
already
allow,
and
this
is
just
about
running
two
command.
What
you
may
not
want
to
do
is
running
your.
That
is
fine
building
your
kasich
binary
for
each
time
that
you
want
to
run
at
a
you
may
want
to
do
one
time
before
the
entire
process,
but
it's
gonna
be
even
okay
with
building
the
k6
version,
maybe
before
each
test.
B
A
C
No,
it's
not
very
common,
because,
okay,
they
may
have
a
not
uncommon
but
think
that
golan
builds
per
operating
system
they
may
be
using
on
mac
and
they
and
this
stat
will
run
on
linux.
So
we
always
because
that
we
are
trying
to
improve
this
process.
There
is
a
project
we
want
to
make
it
easier-
it's
not
very
complex
today,
but
you
need
to
build
the
binary
within
the
operating
system
that
you
will
run.
C
Just
check
with
the
golang
docker
image,
use
a
golan
docker
image
and
check
out
if
you
could
run
a
command
first,
as
we
did
the
first
command
that
we
run.
There
is
download
ak6
and
the
second
is
just
run
and
go
land
command
and
exit
command,
and
you
are
going
to
see
how
it
builds
k6.
And
now
you
have
the
binary,
as
you
have
on
the
on
the
other.