►
Description
All of September, we will be featuring the Kong Summit Hackathon with a live stream every Wednesday to help you get started with contributing to Kong! In this episode, Viktor Gamov and Thijs Schreijer will talk about #plugin development in #KongGateway.
Kong Summit Hackathon details: https://konghq.com/summit-hackathon
#KongHack22 #Hackathon #OSS #opensource #KongBuilders #developer #devops
A
A
A
B
Hello
internet
welcome
to
kong
builders
today's
wednesday
and
meaning
that
we
will
have
some
a
good
time
here.
So
hope
you
see
us
in
the
here
as
well
just
write
down
in
the
comments
where
we're
coming
from
if
you're
coming
from
linkedin
youtube
twitch
wherever
you're
watching
us
twitter,
maybe
even
twitter
twitter.
If
you
have
a
twitter,
you
can
go
and
follow
me
on
twitter
as
well.
B
My
name
is
victor
gamoff,
as
always
today,
but
today
I
have
a
special
guest
for
you
that
I'm
I'm
just
reminding
you
that
we're
doing
this
hackathon
session
a
special
episode
where
we're
gonna
teach
you
some
of
the
conway,
so
you
can
build
something
around
the
corn
and
today
I'm
super
excited.
If
my
button
will
be
working,
I
will
have
my
friend
thais,
I'm
not
gonna
butcher,
his
last
name
because
he
will
pronounce
it
and
whoever
will
pronounce
the
way
he
will
like
the
most
will
get
a
t-shirt
from
us.
C
Hey
thanks
victor
great
to
be
here
yeah,
my
name
as
victor
said,
yeah,
going
to
the
competition
to
win
a
t-shirt
and
try
to
pronounce
thais
surveyor.
B
That's
coming
to
us
from
from
across
the
ocean,
and
we
use
this
opportunity
to
when
the
people
joining
this
live
stream.
They
are
sharing
the.
Where
are
they
coming
from
where
they,
where
their
location,
where
they're
based
off
and
where
are
we
coming
from
to
us
this
morning
at
least
morning
for
me
and
the
morning
for
california?
But
it's
like
late
afternoon
for
you,
I
guess.
C
Yeah,
the
netherlands,
in
this
case
so
yeah,
say,
let's
say,
amsterdam,
not
exactly
in
amsterdam
but
near
amsterdam.
The
netherlands
is
such
a
small
country
that
everybody
lives
in
amsterdam,
pretty
much
so.
B
Pretty
much
every
release
in
amsterdam,
so
can
you
just
for
for
the
conversation
started
and
to
set
the
context
what
you'll
be
doing
this?
What
are
you
doing
at
kong?
Remember
this
movie
office
spaces
when
they
were
doing
interview
and
like
how
you
can
describe
what
you
do
here
and
you
should
respond
like
I'm
good
with
people,
how
you
cannot
understand
this,
I'm
a
good
with
people.
C
Oh
man,
I'm
I'm
exceptionally
good
with
people,
I'm
the
best
with
people
that
that's
bad
bad
these
days
to
say
that,
but
I'm
currently,
I'm
a
I'm
only
positioned
as
a
senior
engineer
in
the
con
gateway
been
with
kong
for
a
long
time
was
one
of
the
first
engineers
actually
joined
the
original
team
and
been
doing
a
lot
of
stuff
around
the
gateway
before.
B
C
B
Been
a
hell
of
a
ride,
what
was
the
story
behind
naming
the
the
quan
quang
yeah?
The
shape
is
kind
of.
I
understand
it's
kind
of
like
a
mesh
ups
api,
my
shops.
All
the
portal
stuff
was
like
very
interesting
at
the
time,
but
what
was
the?
What
was
the
motivation
to
call
the
the
product
clock?
C
My
shape
came
to
be,
as
the
name
come
from
meshing
apps.
So
so
you
mash
them
together
into
one
coherent
thing.
Yeah.
C
And
then
it
became
a
shape
so
something
with
apes.
It's
a
lot
of
jungle,
it
is
apes
and
then
hence
came
kong
as
a
name
for
the
gateway.
C
Once
we
had
the
open
source
product
out,
it
just
took
off
and
after
a
while
it
became
the
main
product
and
the
company
was
rebranded
to
be
kong
as
a
whole.
So.
B
I
I
will
use
this
opportunity
to
to
promote
a
little
bit
of
the
clone
summit
right,
so
speaking
about
the
jungles
where,
where
api
innovation
runs
wild,
so
this
is
the
place
where
you
want
to
be.
Everyone
wants
to
be
because
it's
a
api
world
and
the
innovation
that
we
will
be
delivering
for
coming
years.
B
You
want
to
you
want
to
see
this
the
first
place
and
the
things
what
we
do
in
order
to
kind
of
like
celebrate
and
prepare
for
kong
summit
is
we're
running
virtual
hackathon
and
one
of
the
one
of
the
streams
that
we're
doing.
If
you
join
us
for
the
first
time,
it's
great
welcome
kong
builders.
This
show
that
we're
running
almost
every
week
and
we're
building
stuff
we're
going
to
be
building
some
some
something
unusual
today
we're
going
to
building
something
unusual.
I
hope
you
will
enjoy
this.
B
What
we
prepared
and
yeah
so
for
for
hackathon
to
celebrate
summit.
We
also
suggesting
people
to
to
build
something,
extend
clunk
functionality
that
will
solve
some
of
their
problems
and
maybe
solve
the
problems
in
the
larger
community.
So
they
will
build
something,
and
today
we're
going
to
be
looking
into
native
sdk
native
sdk
that
allows
you
to
build
plugins
in
this
language
called
law.
B
If
you
been
here
a
few
weeks
ago,
I
did
the
show
where
I
explained
how
you
can
build
the
plugin
with
go
and
go
is
more
like
it's,
not
the
afterthought,
but
it's
kind
of
like
something
that
was
added
after
the
lua
was
there
in
the
very
beginning
and
the
law
was,
you
know
the
the
biggest
important
part
of
this
right.
B
So
that's
that's
where
we
that's,
where
we're
gonna
be
doing
this
today,
so
dice,
what
about
we
just
like
roll
our
sleeves
and
we'll
start
start
to
start
doing
the
thing
so
the
way
how
we
were.
B
Yeah,
the
way
how
we
envisioned
this
show,
with
with
dice
before
I'm
gonna,
start
with
the
like
some
of
the
basics
of
the
always
gateway
get
stuff,
and
he
will
here
he
will
be
here
because
he's
one
of
the
one
of
the
developers
who
work
on
pdk
as
well,
and
he
also
developed
a
lot
of
plugins.
So
I
thought
that
would
be
great
to
have
him
on
the
show
and
he
will
be
also
holding
my
hands.
B
While
I
will
be
doing
some
stuff
and
said
victor
just
don't
do
this
because
lua
is
not
my
strongest
suit
yet,
but
I'm
excited
so
we're
gonna
start
with
the
thing:
that's
where
we
should
start.
We
should
start
with
the
pongo
or
we
should
start
with
the
plug-in
template.
I
think.
C
I
think
we
should
start
with
the
plug-in
template.
Okay,.
C
B
Exactly
so,
if
you
go
into
the
con
github,
you
can
find
this
project
called
quant
plugin,
and
this
is
not
just
some
project.
It's
a
template
project,
so
essentially
a
team
at
cone
can
build
a
template
that
will
have
a
structure
of
regular
template
that
you
have
in
for
for
lua
all
the
things
all
automations
are
based
here.
So
what
you
need
to
do
is
just
you
go
ahead
and
just
do
in
fork
with
this
template.
You
call
it
whatever
you
want.
C
I'll
pick,
the
picture,
you
probably
want
to
click
the
not
the
fork
button,
but
since
it's
a
template
you
can
use
template
first
thing.
B
Yeah,
because
exactly
yeah,
so
when
you're
using
template,
you
will
create
a
new
repository
with
this
with
this
plugin
and
you
can
put
this
stuff
in
in
in
place.
I
already
have
a.
B
I
already
have
my
template
that
we're
going
to
be
using
today
and
I
think
it's
called
something
like
cone
builders,
I'm
a
lacking
of
imagination
of
originality,
so
I
will
call
it
kong,
plugin
kong
builders,
one
of
the
things
that
dice
mentioned
to
me
that
this
is
important
to
be
kind
of
consistent
on
the
naming
and
some
of
the
things
that
we
will
walk
through
today
and
see
how
the
naming
is
important.
B
So
I
already
have
this
so
for
my
for
my
local
development,
I'll
just
do
a
git
hub,
repo
clone,
and
I
will
go
into
my
con
plugin
clone
builders.
So
for
consistency
again,
the
naming
should
be
something
like
plugin
dash,
and
this
is
the
name
of
your
plugin.
So
if
you
look
into
some
some
plugins
that
available.
B
You
want
to
call
this
the
you
want
to
call
this
consistency
consistent
with
the
other
tools.
Let
me
make
the
font
bigger,
so
you
will
see
what
I'm
doing
here.
C
Yeah,
while
you
do
that
victor,
if
you
look
at
the
the
the
kit
of
repo
for
the
for
the
template,
the
readme
has
a
list
of.
If
you
scroll
down
to
the
readme,
then
you'll
you'll
find
there's
the
naming
conventions
and
versioning
conventions.
There's
quite
some
names
involved.
There's
packages,
there's
modules
there
is
plugin
names
etc
and
they
relate
to
each
other.
So
once
you
pick
a
name,
try
and
stick
to
the
defaults,
because
that
will
definitely
make
your
life
easier.
B
And
the
many
conventions
that
we
have
definitely
will
make
sense,
while
we
will
be
going
through
this
yeah.
So
now
it's
a
lua.
Why
lua
many
people
asking
this
question
like
while,
let's
yeah.
C
Many
many
people
ask
us
a
language
is
a
it's,
not
a
general
purpose.
Programming
language
lua
is
an
extension
language.
So
typically
you
have
an
application
and
you
want
you
to
provide
scripting
capabilities
to
your
end
users.
So
you
add
lua,
and
then
you
use
this
kind
of
script
or
application
if
most
people
probably
familiar
with
macros
in,
for
example,
microsoft,
excel
or
word,
and
then
you
have
visual
basic
for
applications.
C
Lua
is
basically
an
open
source
version
for
for
visual
basic
for
applications,
so
you
can
take
any
application,
you
add
load
to
it
and
you
make
it
scriptable
and
essentially
the
core
engine
which
is
built
on
top
of
nginx
is
an
nginx
engine
with
a
lua
scripting
capability
on
top
and
and
kong
itself
is
written
in
lua.
C
B
Uses
the
open
rest
that
uses
law
right.
So
that's
the
that's
the
stuff
that
we're
using
to
to
build
the
column
functionality.
C
Yeah,
open
resti
is
a
can
considered
to
be
a
platform
and
a
platform
consists
of
nginx
the
lua
module
that
extends
nginx
and
then
a
whole
series
of
libraries
that
make
development
easier.
When
you
build
applications.
B
So
when
that's
that's,
why
the
the
native
native
sdk
for
for
lua
is,
is
you
know
we
wanted
to
provide
the
tooling
for
the
people
for
starting
to
do
this
extension
like
much
easier
and
doing
the
things
their
way?
So,
let's,
let's,
let's
take
a
look.
What
I
have
here
so,
first
of
all,
what
do
I
see
here
so
right
now
the
fork
doesn't
have
anything
so
first
thing
that
I
want
to
see
here
is
that
it's
not
my
plug-in.
B
It's
called
cone
builders
right,
so
I
can
do
something
like
view
find
where's
the
find
can.
B
Yep,
that's
a
good
point.
It's
always
good
to
have
a
co-pilot
that
can
tell
you
what
is
going
on
here.
So,
first
of
all,
I
want
to
do
and
changed
my.
B
B
So,
let's
see
okay
cool
now,
the
another
thing
that
probably
makes
sense
to
do
is
to
rename
this
lua
rocks.
So
lua
rocks
is
a
package
manager
that
allows
you
to
to
redistribute
your
lua
programs
or
rural
applications,
and
that's
makes
sense
to
to
call
it
also,
my
not
my
plugin,
but
my
clone
builders.
C
Yeah,
actually,
it
has
to
be
because
otherwise,
you'll
you'll
get
errors
thrown
at
you
by
lower
rocks.
B
Again,
if
you
are
in
doubt
any
time,
go
and
read
this
readme
that
will
be
available
in
your
repository
since
you
use
this
template,
it
will
be
part
here.
B
B
C
Have
you
changed
already
in
the
folders,
the
spec
folder,
which
contains
the
tests?
Have
you
you
name
it
so
the
my
plugin.
B
It's
very
similar
to
it's
kind
of
like
a
package
structure
right,
so
in
this
case
it
will
be
using
the
the
clone
plugins
com
builders.
It's
going
to
be
your
name
space
or
how
you
call
it
in
lua,
not.
C
It
basically
it's
it's.
Basically,
you
can
consider
this.
A
plug-in
can
be
considered
like
a
class,
so
this
is
a
class
of
plugins
and
then
you
can
apply
multiple
instances
while
the
system
is
running,
but
the
plug-in
code
itself
is
the
class
that
contains
all
the
code
that
executes.
B
Right
so
in
in
order
to
you
continue
to
do
the
some
some
of
the
things
now
you
need
to
have
some
sort
of
tooling.
So
last
time
I
showed
you
when
you're
using
the
pdk,
it's
good
to
run
the
quantum
container
and
after
that,
bring
the
plug
in
this
and
build
the
build
the
the
plugin
in
the
in
in
the
platform
that
you're
running.
B
So
when
we're
using
pgk,
we
kind
of
people
can
rely
to
whatever
tools
they
use
on
a
particular
platform,
whatever
you're
building
for
go
whatever
you're
building
for
python,
whatever
building
for
javascript
here
we're
providing
you
with
can
can
we
say:
can
we
say
opinionated
opinionated
way
to
do
the
things
right,
so
I
think
we
can
say
that
yeah-
and
this
is
what
brings
us
to
very
cool
a
framework
or
like
a
set
of
tools
that
called
a
pongo,
not
a
maybe
pongo,
just
just
pongo,
and
we
continue.
B
I
think
we
continue
to
to
this
ape
and
the
primates
theme,
and
the
pond
go
also
has
something
to
do
with
this
thighs.
Can
you
talk
a
little
bit
about
like
what
is
pawn
going
like
why
it
came
about.
C
Pongo
came
about
as
we
had
more
and
more
customers
developing
custom,
plugins
and
and
open
source
users
likewise,
and
he
needed
a
way
to
test
it
initially.
When
we
started
off
years
ago,
the
application
itself
was
fairly
easy
to
install
and
locally,
and
then
you
could
also
test
the
plugins.
But
at
some
point
it
became
for
people
that
wanted
to
do
just
like
minimal
coding
on
a
small
plugin,
but
then
had
to
set
up
an
entire
application
and
build
stuff
from
source.
That
became
a
hassle.
B
Yeah
we
have
a
good
good
question:
what
are
plugins
in
we
get
in
quank.
What's
so,
if
you
go
into
it's
me,
it's
my
channel
yeah.
If
you
go
to
docs.com.hq.com.
B
Hub
you
will
get
into
plugin
hub
and
you
will
see
what
kind
of
plugins
you
can
get.
You
can
get
a
free
plugins
that
are
free
in
open
source.
You
can
go
and
check
this
out
and
some
of
these
plugins
you
can
go
and
look
source
code
and
how
they,
you
know,
work
with
the
external
systems,
and
things
like
that.
Some
of
the
plugins
will
include
it
will
be
included
in
some
enterprise
subscriptions.
So
but
this
is
the
good
place
to
start
to
to
know
what
are
the
plugins
and
there's
even
article?
B
It's
a
really
so,
let's
see,
for
example,
we
can
open
this
with
lambda
plug-in.
We
can
see.
If
we
can,
we
can
invoke
aws
lambda,
so
it's
supported
by
conc,
so
it's
safe
to
assume.
If
I
go
somewhere
like
a
cong,
plugin
sorry
go
to
clone
repository,
it's
better
to
go
there
in
private
mode,
because
I
don't
want
to
show
you
every
every
secret
that
we
have
there
in
in
the
public
repository
since
I'm
a
part
of
the
kong
team,
and
if
I
see
aws
here.
B
So
we're
going
into
congruence.
C
Yeah
and
then,
if
you
go
into
plugins
first
first
kong
and
then
plugins.
B
B
C
B
And
we
will
see
something
like
handler:
that's
we're
going
to
talk
about
the
structure
of
the
plugin
in
a
few
seconds
just
like.
If
you
it's
not
somewhere,
you
can
go
and
look
how
it's
done
with
some
some
other
plugin.
For
example,
you
want
to
integrate
this
with
google
cloud
functions,
and
this
is
where
you
can
start
to
learn
how
you
can
do
this
now.
B
B
Support
engineers
to
building
the
tools
and
we're
going
to
be
using
this
one
today
for
for
first
of
all
to
validate
what
this,
what
this
plugin
does
so
first
of
all,
this
plugin
already
has
some
basic
functionality
on
adding
some
some
extra
headers,
and
we
will
show
you
in
in
a
second
how
it
works,
and
so,
let's,
let's
run
this
with
pong,
what
what
the
pawn
go
can
do
for
us.
B
I
already
have
pond
go
installed
in
in
my
computer,
so
it's
it's
already
installed,
but
you
can
follow
along
in
in
installations
instructions.
So
it's
it's
quite
simple.
You
essentially
need
to
fork
it
and
just
add
the
the
the
point
binary
into
into
your
path,
and
you
will
be.
You
will
be
good
to
go
whenever
you
need
to
update.
C
Maybe
it's
maybe
it's
good
to
to
have
a
small
explanation
about
what
pango
does
and
how
it
works.
Here
is
if
you
scroll
up
to
the
to
the
commands,
you'll
see
that
there's
two
types
of
of
commands
all
the
way
to
slightly
more.
C
I
can
show
on
the
on
the
on
and
then
there
is
yeah
we
could
show
on
the
console
as
well,
but
there's
here
you
can
see
there's
project
actions
and
the
the
second
thing
is
an
environment
actions.
Pongo
is
built
around
docker
compose
because
quite
often,
when
you
need
to
test
something,
you
need
dependencies.
So
you
need
a
database
to
write
your
configuration
in
you.
C
If
you
create
a
logging
plugin,
you
want
to
spin
up
a
log
server,
so
you
make
sure
that
the
communications
is
there
and
that
is
essentially
the
environment.
So
the
environment,
environmental
actions
that
you
have
with
pongo
are
aimed
at
getting
that
environment
spun
up
tearing
it
down,
cleaning
it
up
everything
you
need
and
then
there's
the
project.
Actions
and
the
project
actions
specifically
are
focused
on
your
plugin.
So
you
want
to
lend
them.
C
You
want
to
run
them,
you
want
to
pack
them
or
you
want
to
create
a
local
shell
to
create
those
are
specific
to
your
project.
So,
typically,
what
you
would
do,
you'd
spin
up
an
environment
and
then
you
start
working
with
your
project
commands
and
when
you're
done,
you're
tearing
it
everything
down
the
environment
again
and
the
whole
thing
like.
I
said
it's
based
on
docker
compose.
So
if,
if
you're
familiar
with
docker
docker
compose,
you
can
like
dig
in
and
see
everything
that's
running
in
a.
B
So
what
we're
gonna
start
with
is
just
to
run
pongo,
let's,
let's
do
start
from
from
from
very
beginning
like
to
make
sure
that
we
don't
have
anything
in
here.
We
should
do
one
go
clean,
we'll
just
just
to
make
sure
that
I
don't
have
anything
so
like.
Let's
imagine
we
started
from
the
very
beginning.
The
first
thing
that
you
probably
want
to
do
is
something
like
pond
go
up
right
that
allows
you
to
start
all
these
containers
again,
as
I've
mentioned,
we're
using
the
docker.
B
So
docker
needs
to
be
installed
what
we
found
while
preparing
for
the
show
that
works
fine
with
docker
for
desktop
with
some
alternative
distributions.
It
might
we
might
experience
some
of
the
your
your
mileage
might
vary
if
you're,
using
some
alternative
installations.
So,
and
when
I
run
this,
I
can
do
status.
B
So
when
I
run
the
status
in,
I
see
that
pongo
already
started
through
containers.
So
many
of
you
know
that
when
you're
running
kong
you
can
use
this
in
dbls
mode
or
you
can
use
this
in
with
database.
B
If
you
don't
know
the
difference
somewhere
here
after
the
stream,
you
will
see
the
link
to
my
video,
where
I'm
explaining
how
to
run
qualcomm
docker
in
two
modes,
and
you
will
get
this
idea
like
someone
here
that
I
think
I
think
so
somewhere
here
it
will
be
there
and
now
so
we're
going
to
be
using
two
databases,
cassandra
and
posgress
it's
one
of
the
modes
that
support
in
future.
Maybe
cassandra
is
already
duplicated,
so
we
will
get
rid
of
it.
B
However,
in
the
old
version
you
still
might
need
to
support
this
in
your
plugin,
if
you're
going
to
do
backward
compatibility
or
whatever
and
now
so
so
since
I'm
in
the
directory
of
my
plugin.
So
I'm
still
here
in
the
micron
builders.
So
that's
what
I
need
to
do
in
order
to
start
testing.
So
I
write
something
in
my
plugin,
so
just
you
know,
we
need
to
make
sure
that
at
least
basic
functionality
of
the
template
is
working.
How
I
can
how
I
can
check
if
it's
working.
B
So
pongo
has
this
container
that
include
all
developer
tools
based
on
particular
clunk
version.
So
since
I
clean
up
this,
this
version
of
this,
the
ponder
shell
or
what's
called
congo
test,
it's
going
to
be
local
imaging,
that's
going
to
be
published
first
time.
It
will
do
kind
of
installation
install
all
the
tools
that
you
need:
jq,
hd,
pi,
all
the
regular
suspects
right
and
we're
gonna
we're
gonna
try
to
do
a
first
thing
that
we
call
the
manual
test.
B
So
with
the
manual
test
we
need
to
start
the
quant
configure
plug-in
the
configure
service
and
try
to
invoke
the
some
end
point
with
with
this
particular
this
particular
plugin
enable,
while
it's
doing
this
so
right
now
we're
still
building
image,
and
it
was
much
faster
when
we're
doing
this
together.
But
right
now.
B
Like,
thankfully,
new
hardware
that
we
have
these
days
is
is
quite
capable
of
running,
live
stream
plus
building
docker
containers.
So,
as
you
can
see
here
when
we
running
the
shell,
it
has
a
prompt
and
some
of
the
aliases
for
starting
starting
the
things
so
we're
gonna
start
with
the
quant
in
the
database
mode.
So
in
this
case
we're
going
to
be
using
quang
kms,
which
is,
it
will
start
quank.
It's
connected
at
the
base,
execute
migrations,
so
the
structure
of
the
configuration
will
be
placed
in
database
again.
B
Look
to
this
video
where
I
show
this
in
in
details,
so
go
to
kms
and
now
it's
starting
a
configuration.
So
it
says
declarative
configuration
not
found,
but
we're
going
to
talk
about
this
in
talk
about
this
later.
B
Ship
http
say
port,
I
I
do
have
it
somewhere
config.
So
let's
do
so.
What
I
did
this,
I
just
curl
admin
api
for
configuration.
B
So,
let's
see
if
we
have
our
plugins
here
and
there's
a
bunch
of
stuff
loaded,
plugins-
and
you
see
calling
builder
is
already
here
and
the
way
how
it's
done
is
that
when
we're
starting
the
clone,
we're
already
providing
configuration
with
this
plugin
enabled
so
see
with
the
configuration
we
can
have
a
bundle.
B
So
all
the
plugins
that
we
have
with
open
source
version
would
be
enabled
and
conc
builders
again,
you
can
watch
the
previous
stream,
where
I
also
talk
about
this,
how
you
can
enable
in
the
go
this
is,
but
this
is
like
much
easier.
It's
already
tooling,
tooling,
make
this
easier
for
you
all
right.
So
the
next
thing
that
we're
going
to
be
doing
is
to
let's
enable
this
plugin
and
see
if
this
plug-in
in
action
right,
let's
see
if
we
have
a
service
okay.
B
B
Yeah
it-
and
it's
always
have
a
it's
always
great-
to
have
a
co-pilot
in
this
type
of
shows
when
the
when
the
our
audience
are
not,
let's
see
if
we
have
any
comments
so
far,
no,
sometimes
sometimes
you
know
we
have
a
a
lot
of
people.
B
Sometimes
we
have
not
so
many
people
and
people
just
like
okay,
so
we
will
just
sit
here
and
see
what's
going
on
so
when
I
do
mistakes,
mistakes
that
happen
now
so
we're
doing
this
next
thing
is
to
do
is
to
we're
adding
the
path
path
here.
So
with
the
insomnia,
we're
gonna,
do
this
services
name
of
the
service
and
routes,
so
we
just
do
services.
B
And
root-
plural,
plural,
yep.
So
now
the
service
is
modified.
We
do
have
here.
So
if
I
will
do
something
http
to
port
oops,
we
should
get
the
response
from
http.
So
this
is
the
request
that
the
request
is
echoed
here,
headers
from
request
here
and
the
this
is
response,
so
we
we're
going
through
the
quantum
proxy
now
all
good,
and
the
next
thing
is
that
we
need
to
enable
plug-in
right.
B
So
we
just
do
plug-ins,
so
we
need
to
hit
the
plug-ins
with
a
name
and
some
of
the
configurations.
So
we
let's
take
a
look
on
the
plugin
itself
when
we're
looking
into
schema.
B
We
do
have
some
required
configuration
parameters
here
right,
so
we
do
have.
This
schema
file
will
be
responsible
for
defining
a
structure
of
configuration
for
your
plugin
and
internally.
The
quank
will
be
using
this
schema
information
to
introspect
what
kind
of
parameters
required
for
your
plugin.
This
is
the
solely
for
your.
You
know,
whatever
you
want
to
do
with
the
with
configuration,
you
need
to
define
this
in
this
schema.lua
file.
B
So
what
I
see
here
that
we
have
a
few
configuration
fields,
request
header,
reque
response
header
and
they
those
are
required,
but
we
also
have
a
default
value
for
them,
so
they
kind
of
required,
but
not
necessarily.
We
need
to
go
in
the
define
this
in
our
configuration,
so
what
we
can
do,
http
the
port,
81
plugins
and
the
name
coin
builders,
so
we're
going
to
enable
this
global
plugin.
So
the
next
time,
as
you
can
see
here,
that
the
config
was
was
used
and
the
default
default
configuration
was
used.
B
That's
that's
pretty
much
it
like
that's
how
you
can
do
a
manual
testing
of
your
plugin
and.
B
C
I
think
I
think
what
was
worthwhile
pointing
out
here,
because
it's
it
can
be
quite
tedious
to
create
a
manual
test
setup
like
this.
One
of
the
aliases
that
that's
in
here
as
well
is
an
export
alias,
so
you
can
do
a
kx
and
it
will
export
the
current
configuration
as
it
is
and
export
it
due
to
a
congratula
file.
B
And
the
cool
thing
that
this
this
file
also
will
be
available
outside
of
the
container
so
see
since
we
mount
this
folder-
and
you
see
this
configuration
in
in
the
clone
format
and
we
have
a
service
one
service
that
hits
anything
on
http
bin
with
route.
A
C
Actually,
now
and
now,
if
you
would
like
clean
the
databases,
restart
the
environment
and
and
do
kms
again.
B
So,
as
you
can
see,
we're
killing
the
containers
for
cassandra
for
postgres
and
we
killed,
oh,
you
killed
the
network.
So
now
it's
gone
so
essentially,
whenever
you
need
to
do
this
kind
of
clean
up
just
do
restart
and
it
will
be
clean
so
next
time.
If
I'll
do
this
one
go
but.
B
Be
careful,
it's
splendor
miseries
of
containers
right,
so
you
can
have
you
can
start
any
type
of
software
very
easy,
but
you
know
be
careful
if
you
playing
around
with
this
and
you
know,
kill
some
data,
make
sure
that
this
date
is
export
somewhere.
Now,
if
I
will
run
this
up
again
right,
so
I
need
to
bring
the
base
up.
B
B
B
Yeah
yeah,
when
I
did
the
restart
it's
already
up.
Okay,
so
in
this
case
I'm
just
getting
back
to
shell
and
what
it
will
do,
we
didn't
tear
down
the
whole
environment,
so
the
shell
was
available
to
container
just
restart
it
now.
So
when
I
run
this,
I
can
run
the
kms
right.
I
can
run
the
kms
and
it
will
be.
B
The
bringing
the
the
database
and
configuration-
and,
let's
let's
do
this
one,
showing
this
one
more
time,
what's
what
would
be
different
now?
It's
found
the
quant
gammel
and
import
declarative
configuration.
So
when
identity
do
is
http,
say:
port
88,
oops
8080..
B
Now
the
plugin
in
the
service
is
already
configured
so
because
it
was
able
to
bring
this
from
from
the
from
the
file.
So.
B
Kp,
kong
stop
and
now
I
can
do
kdb
dbl
dbl,
so
now
it
will
start
quank
without
that
connection
to
database.
But
since
we
already
have
a
configuration
file,
our
services,
you
will
not
be
able
to
call
the
the
services
endpoint
and
admin
api
in
dbls
mode.
B
Dbls
mode
will
require
the
configuration
file
available
for
youtube
configuration,
but
this
is
kind
of
like
different
options
that
you
can,
that
you
can
try
and
try
try
around
and
play
one
last
thing
that
before
I
will
pass
my
my
the
steering
wheel
to
masters
and
experts
in
in
something
cool.
So
we
would
we'll
see
how
we
can
do
like
something
more
complex
things.
I'll
show
you
that
this
repository
is
is
is
pretty
dope
because
it's
also
including
some
of
the
github
actions.
B
So
whatever
you
will
be
pushing
to
your
github,
we
already
have
some
of
the
actions
that
you
can
run
the
test
in
in
in
cicd
pipeline.
There's
a
per
pull
request.
B
The
you
can
run
the
test,
different
metrics
of
versions
that
you
can
run
against
and
the
what
I
wanted
to
show
you
that
you
can.
You
can
do
the
local
run
of
this
of
this
test,
so
all
the
specs
that
you
have
inside
this
will
be
executed
through
through
this
test.
So
if
I
run
the
pongo
pongo
run
inside
directory
of
my
plugin,
it
will
pick
up
the
the
tests
and
it
will
execute
those
tests
in
automatic
fashion.
B
We
there's
a
configuration
that
we
have
for
pongo
and
it
uses
postgres
and
cassandra
right
now,
so
it
will
start
upon
going
cassandra
and
all
the
tests
will
be
executed
against
a.
B
C
In
fact,
one
of
the
nice
things
here
what
you
see
is
because
you
can
define
your
own
dependencies.
So
if
you
there
is,
for
example,
an
open
source,
plugin
called
sipkin
that
defines
an
external
dependency
version
server
and
that's
embedded
inside
your
plug-in
test
environment.
So
if
you
use
this
repo
and
pongo,
then
you
can
one-on-one
move
it
in
your
ci
system.
Do
pongo,
run
and
pongo
will
take
care
of
the
rest
of
it.
It
will
start
all
the
dependencies
will
start
pulling.
B
Okay,
let's,
let's
take
a
look,
so
it's
in
a
convertible
and.
C
Then,
but
the
the
essence
is
that
pongo
takes
the
hassle
out
of
it.
So
you
don't
have
the
right
complex,
ci
script,
that's
starting
all
your
dependencies,
configuring
them
it's
just
a
pongal
run
and
ponga
will
spin
up
docker
compose,
set
up
all
the
environments
and
then
run
the
tests.
C
Yeah
here
you
have
to
go
to
the
top
level
top
level
and
then
into
the
spec
folder,
which
is
where
the
tests
reside
and
then
there's
plugins
number
three.
B
C
C
There
is
definitely,
I
think,
the
old
the
old
sipkin
repository
is
still
around
so.
B
Okay,
we'll
just
do.
B
Okay,
yeah,
it's
archived,
but
it
will
give
the
give
the
id.
C
But
if
you
define
the
dependency
pongo
will
find
it
and
will
use
this
snippet
to
actually
spin
up
a
sipkin
container
according
to
this
configuration
so
how
how
build
those
all
of
that
is
documented
in
the
fungal
readme.
It's
it's
a
bit
too
much.
I
think,
to
go
off
today,
but
yeah.
B
Yeah,
so
that's
it's
it's
already
there,
so
you
can.
You
can
go
and
learn
the
yourself,
so
we
were
thinking
again
and
I
showed
you
how
to
do
the
run
the
plugin.
So
basically,
if
I
will
just
go
ahead
and
do
things
like
to
do
if
I
do
stuff
like
this,
let
me
push
this
files
into
my
stage
all
and
let
to
get.
I
don't
need
this
stage
I'll
just
do
push
and.
B
I
want
to
show
the
one
last
thing
here
and
we're
going
to
talk
a
little
bit
about
the
in
internals
of
plugins
and
how
we
can
how
it
works
from
from
from
integrating
what
parts
of
the
conf
we
can
integrate.
So
I
just
did
the
actions.
Let's
see,
let's
just
run
the
test
15
hours
ago.
B
Yeah,
and
the
thing
is
that
my
my
action
will
include.
B
Enterprise
nightly
ee,
and
it's
it's
not
there,
but
some
of
the
tests
will
be
will
be
working
because
previously
it
failed
because
of
the
naming
conventions
and
all
this
type
of
stuff.
Now
it
should
be
it
should
be.
It
should
be
ready
to
use
all
right.
So
we
we
we
look
into
this
one.
B
The
two
two
files
important
the
handler
is
basically
where
we're
gonna,
defining
our
logic
and
if
we're
gonna
be
looking
to
the
something
called
like
the
axis
phase
or
the
header
filter
and
all
these
type
of
things.
This
is
where
we
can
interject
and
different
phases
of
the
of
the
request
and.
B
I'm
passing
this
to
dice.
Let
me
know
when
your
screen
will
be
ready
to
to
show
this
and
I'll
pass
this
to
you.
So.
B
The
yeah,
the
request.
B
Request
response
life
cycle
and
where
you
can
interject.
B
Okay,
we're
switching
back
to
yep.
We
are
now.
C
Yes,
so
I
essentially
did
the
exact
exercise
same
exercises.
What
figured
it
with
I
just
created.
A
plugin
called
mini
auth
create
a
repo,
it's
just
a
fresh
clone
of
the
same
template.
C
If
we
go
into
a
code
editor,
then
what
we
find
here
is
some
of
the
ci.
Let's,
let's
first
start
with
why
the
thing
failed,
as
viktor
was
just
showing.
If
you
look
at
the
tests,
then
we
can
see
that
we
have
enterprise
versions
here.
So
if
we
remove
those,
we
only
have
open
source
versions
left
and
then
the
license.
C
Also,
we
don't
need
to
get
because
we
don't
have
an
open
enterprise
version
anymore,
and
this
should
be
good
enough
to
get
this
going,
wait
doing
a
check
that
is
not.
This
is
yeah.
This
one
should
go
the
conversion.
Is
there
the
license?
We
don't
need
s
commented
here.
C
So,
let's
save
this
one
now,
if
we
take
a
look
at
a
plugin
and
the
the
everything
that
we
have
in
this
repository,
because
there's
a
lot
of
files
in
here
at
the
top,
we
have
the
standard,
github
workflows,
then
there's
pongo
with
some
configurations
kong
is
where
we
actually
have
our
plugin
spec
is
where
we
return
our
tests
and
then
there's
a
series
of
configuration
files.
Busted
busted
is
a
lower
test
framework
and
that's
what
runs
the
tests.
C
It
has
a
configuration,
but
this
is
like
all
documented
in
the
standard
process
tools
how
you
can
use
it
editor
config
is
nothing
lewis
specific.
It's
just
a
generic
editor
setup
that
strips
trailing
white
space
make
sure
that
the
indents
are
correct,
etc,
get
attributes.
C
If
you
are
developing
on
windows,
then
this
will
make
sure
that
the
plugin
gets
the
proper
line,
endings
et
cetera,
and
this
and
there's
no
issues
with
that.
Git
ignore
also
the
usual
blue
check
is
a
linter.
Lu
is
a
dynamic
language,
so
it's
easy
to
make
typos,
so
lu
checks
definitely
recommended
to
use
to
to
link
your
plugins.
C
Lua.
Cuff
is
a
coverage
analysis
tool
that
can
be
used.
Then
we
have
a
license
which
by
default
is
the
apache
license,
there's
a
readme
and
then
there's
a
rockspec
as
if
it
was
already
mentioned.
The
rock
spec
essentially
is
a
as
a
sort
of
a
manifest
file
for
when
you
distribute
your
plugins.
C
Whenever
you
describe
yeah,
if
you
look
at
the
little
rocks
web
page,
let's
say:
go
to
bluerocks.org.
C
Then
you
can
quickly
see
if
you
search
for
kong,
for
example,
that
your
plugin,
whatever
it
is,
you're
going
to
write,
definitely
quite
a
few
things.
There
yeah
definitely
not
going
to
be
the
first
one,
nor
is
it
going
to
be
the
last
one.
So
this
is
this
is
where
you
can
find
lots
of
plugins
and
you
can
use
command
line
tools
to
get
them
installed
and
actually
run
them
going
back
to
the
editor.
C
C
This
is
now
all
saved,
so
now,
let's
see
if
we
can
get
the
same
thing
going,
I
am
in
a
shell
in
the
same
directory.
Let's
check
fungal
status,
to
see
what
we
have
up
and
running.
C
C
And
then
we
make
sure
that
we're
going
to
run
only
one
set
of
tests
instead
of
three
sets
of
tests,
so
we're
only
going
to
run
the
postgres
test
and
and
all
the
other
ones
we're
gonna
skip.
C
This
is
by
the
way
the
environment
variable
is
the
way
you
you
specify,
which
conversion
you
want
to
test
against
and
we're
gonna
set
it
in.
B
In
a
particular
in
a
particular
shell,
so
it
can
be,
you
know
you
can
you
can
try
to
run
different
version
of
columns
against.
C
Yeah
yeah
and
you
can
even
run
it
in
parallel.
It's
maybe
good
to
know
like
here.
You
can
see
the
names
they
all
have,
an
suffix
which
is
a
which
is
a
hash
of
the
directory
in
which
the
plugin
is
located,
and
this
is
especially
important
if
you
run
plugins
plugin
tests
in
parallel
in
ci
that
you
can
run
multiple
plugin
tests
in
parallel
on
the
same
vm
without
having
any
collisions
between
the
environments.
B
And
how
it's
so
it's
a
created
network
per
per
directory
right,
so
in
per
plugin
directory.
C
B
So
so
right
now,
we
kind
of
like
we
modify
the
things,
because
we
don't
need
cassandra,
I
just
I'm
just
reiterating,
and
so
instead
of
kind
of
like
using
all
spec
kind
of
configuration,
we
you
saw
how
thighs
did
this
in
in
a
config
yeah.
C
In
your
test,
we
saw
that
we
had
now.
We
see
only
four
lines,
essentially
there's
two
tests.
Each
test
has
a
start
and
an
end,
a
run,
an
okay,
so
there's
two
tests
here,
and
these
are
labeled
with
postgres
and
the
other
ones
that
we
saw
in
yours
were
labeled
with
cassandra
and
dblis,
and
I
just
disabled
them
just
for
the
sake
of
yeah
speed,
basically
always.
B
I
always
do
this
when
disable
all
my
tests,
when
you
know
for
the
speed.
C
Yeah
disabling
all
the
tests
is
really
fast,
that
is,
that
really
helps
yeah.
So,
let's
see
let's
go
into
what
we
can
do
with
a
plug-in
because
fedora
already
explained
this
is
the
the
plug-in
schema
and
the
schema
defines
the
configuration.
I'm
not
going
to
add
too
much
on
it
here.
C
Let's
go
into
the
handler
and
the
handler
defines
hooks
basically
in
in
the
flow
of
a
request,
there's
several
hooks
where
lower
code
can
execute
and
can
modify
the
request
and
change
things
or
interact
with
it
or
reach
out
to
remote
server
to
validate
the
stuff
and
either
allow
or
reject
or
request
anything
anything
you
like
to
do
with
requests
pretty
much.
C
Now.
If
you
look
at
the
template,
you'll
see
that
we
have
a
plug-in
definition.
It
has
a
priority.
The
priority
set
statically
set
in
what
what
does
it
mean.
B
C
It
depends
on
the
order
in
which
you
wanted
to
run.
There
is
some
logic
to
it,
specifically
anything
that
requires,
for
example,
authentication
to
be
set
already.
For
example,
the
access
control
list
plugin
requires
that
authentication
has
run
before
it.
So
the
access
control
has
a
as
a
lower
priority
than
the
authentication
plugins
that
ensures
that
authentication's
plugins
run
first
identify
the
specific
consumer
or
user,
and
only
then
it
runs
the
access
control
list
to
validate
whether
the
user
actually
is
allowed
to
yeah.
B
And
this
is,
this
is
very
important
for
when
you
have
a
chain
of
plugins
is
also
very
important,
so
it
basically
there's
a.
I
don't
know.
Is
it
misconception,
but
I
saw
some
people
like
thinking
that,
oh,
if
I
would
specify
plugins
in
certain
order
in
my
configuration
file,
they
will
be
executed
in
this
order.
So
that's
not
a
precisely
correct
assumption.
C
That's
not
not
precisely
correct
and
also
there's
things
are
changing,
so
this
one
has
a
thousand,
which
is
a
common
priority
for
the
pre
3.0,
which
was
released
this
week
after
3.0.
The
priorities
have
shifted
because
we
had
too
many
plugins.
We
didn't
anticipate
this
many
plugins,
so
we
had
too
many
plugins
too
close
together.
So
now
we
we
loosened
the
space
up
to
make
sure
that
we
have
enough
room
for
customers
to
inject
their
plugins,
as
so.
C
I
think
a
thousand
is
the
old
one.
This
is
the
old
one.
I
don't
even
know
what
what
the
new
one
is,
but
there's
more
room
between
the
plugins
and
it's
a
new
really
great
feature,
but
that's,
unfortunately,
on
the
enterprise
that
allows
you
to
create
dynamic
priorities.
So
when
you
configure
a
plugin,
you
can
change
the
priority
when
it
runs.
It's
also
a
very
dangerous
thing.
This
is
a
very
highly
requested
feature,
but
it's
also
dangerous
for
the
same
reason
that
I
mentioned
before.
B
One
foot
you
know
if
you're
interested
in
this
type
of
jazz,
you
can
look
up
for
the
plug-in
that
thai's
developed
it's
kind
of
like
a
tool
that
can
change
the
static
priority,
but
it
will
basically
generate
new
new
plugin
that
you
need
to
rebuild
and
deploy,
but
for
enterprise
version
and
3.0
stay
tuned.
Actually,
I
was
working
on
the
blog
post,
for
this
very
soon
will
be
published
about
the
how
this
works
and
how
you
can
use
this
in
your
application.
B
So
just
here's
the
his
inside
scoop
for
you,
the
attendees
of
the
livestream.
C
Okay,
so
back
to
the
plugin
code,
because
here
what
we
see
is
we
see
a
number
of
functions
that
are
being
defined.
This
one
is
called
init
worker,
we'll
come
back
to
that
one.
This
one
is
commented
out
because
it's
not
used
in
this
template.
C
We
can
simply
remove
a
comment
by
making
adding
an
extra
dash,
and
now
you
can
see
the
colorization
that
it
actually
gets
enabled.
Now
this
is
a
another
hook
when
the
ssl
certificate
comes
in.
You
want
to
check
something
on
that
one
and
there's
more
of
those.
Now.
Obviously
main
question
now
is
like
what
are
those
things
and
what
can
I
do
with
them?.
B
Where
you,
where
you
basically
inject
your
logic,
so
as
you.
B
Plugin
is
essentially
sit
somewhere
in
your
request
response
between,
so
the
gateway
is
the
something
that
sits
between
your
upstream
service.
We
call
all
the
services
that
we
be
sitting
behind
calling
upstream
service
and
where
you
need
to
put
your
logic,
that's
a
very
good
question
and
let's,
let's
talk
about
this.
C
So
so
so
what
are
those
hooks?
And
how
does
that
work?
This
is
a
diagram.
It's
not
a
kung
diagram.
It's
actually
an
open,
resty
diagram
that
displays
the
the
different
phases
that
a
request
goes
through
in
an
nginx
instance
or
open
wrestling,
and
the
requests
are
actually
handled
basically
like
top
to
bottom.
Through
this
flow
diagram,
and-
and
some
of
these
have
come
hooks-
some
don't.
If
you
look
at
having
a
client
on
the
left
and
an
upstream
service,
that's
actually
providing
the
service
with
congress
proxy
in
the
middle.
C
C
The
final
phase,
the
log
phase,
which
is
outside
of
this
request
response
cycle.
That's
exactly
what
it
is.
It
is
outside
the
cycle
because
the
log
phase
runs
asynchronously
after
the
response
has
been
sent.
So
logging
will
never
delay
a
response.
It
will
not
add
to
your
latency
now.
This
is
how
it
works.
How
does
that
sorry
too,
quick,
there's
one
more
which
is
here
at
the
top.
You
can
see.
C
There's
also
two
application
level
hooks
in
it
by
lua
and
the
inner
worker,
and
these
are
hooks
that
you
can
do
to
do
initialization
when
the
application
starts.
They
run
once
everything
else
at
the
bottom
is
on
a
per
request
level,
whereas
the
top
two
only
run
when
on
application
start
or
or
reload
or
restart.
B
Is
it?
Is
it
fair
to
say,
for
example,
if
you're
dealing
with
some
external
service
and
you
need
to
establish
like
initial
connection
or
whatnot,
you
need
to
run
this
in?
You
need
the
phase
kind
of.
Like
a
you
know,
your
start
connection,
no.
C
Only
if
you
need
to
connect
some
init,
you
have
to
fetch
some
initial
state,
but
definitely
not
long-lived
connections.
You
should
not
be
creating
those
okay.
B
C
Think
the
long-lived
yeah
it's
quite
detailed,
but
the
engine
itself
will
use
connection
pooling.
So
from
code
perspective,
you
recreate
the
connection
every
time
under
the
hood.
The
connection
is
kept
alive
and
it's
reuse
and
re-using
reuse.
C
C
Here's
the
same
picture
with
the
request
and
response
and
the
green
arrows
sort
of
like
relate
to
like
the
original
faces
that
you
that
we
had
to
what
kong
can
do
so
the
interface
it
runs
when
con
gets
loaded,
there's
an
inner
worker
and
then
for
each
request
as
a
certificate
to
rewrite
in
the
access
phase
sounds
like
a
lot.
What
do
you
need
to
know
when
you
start
pretty
much
access
phase
access?
The
access
phase
is
like
the
workhorse
of
this.
C
This
the
schema
it
runs
like
95
off,
like
all
plugins
execute
in
the
access
phase,
probably
from
the
remaining
five
percent.
Four
and
a
half
percent
will
probably
run
in
the
header
filter
phase
on
the
way
back
on
the
response,
and
everything
else
is
yeah,
probably
logging
body
filter
certificate
rewrite
are
very
solidly
used
only
if
you
have
very
specific
requirements.
B
A
B
I'm
just
thinking
the
functionality
of
the
you
know,
request
transformer
and
the
request
response
transformer
type
of
plugins,
where
you
should
put
logic
for.
C
B
Because
if
I
want
to
do
something
like
if
I
want
to
do
something
like,
I
don't
know
the
the
xml
to
json
transformation,
I
should
do
this
in
in
body
phase
right.
B
Here's
the
idea
for
our
like
attendees,
who
watch
this
right
now
like
in,
don't
have
any
idea
what
to
do
with
in
hackathon
like
write,
something
that
transforms
your
soap
service
to.
I
don't
know
graphql
whatever.
C
Yeah
definitely
definitely,
but
at
least
here
you
have
an
overview
of
like
how
the
the
process
of
the
request
flow
will
actually
work
with
the
hooks
that
we
have
defined
inside
the
code.
So
in
the
code
we'll
see
the
init
worker
certificate,
rewrite
access,
header,
filter,
body,
filter
and
log
phase,
and
we
close
this
down
here
we
are-
and
let
me
just
get
some
of
this
stuff
out
of
the
way,
because
there's
a
lot
of
boilerplate
stuff
here.
C
So,
let's
remove
here,
we
have
in
it
worker
which
we
won't
be
using.
Then
a
certificate
I'll
also
not
be
using
this
rewrite.
We
will
not
be
using
this,
and
here
we
have
the
access
phase.
This
is
where
most
of
the
stuff
is,
and
this
is
also
where
the
current
template
code
is
header
filters
on
the
way
back,
so
we're
not
going
to
use
that
either
so
we're
going
to
remove
it
body
filter
we're
going
to
remove
it
and
then
it's
a
logging.
B
Why,
while
does
the
cleanup
I
want
to
say
that
the
same
phase
is
available
in
other
pdk,
ptk
sdks
like
in
javascript,
and
go
so
the
same
similar
idea?
You
know
if
you
want
to
do
modification
in
a
in
a
previous
stream.
I
show
how
you
can
do
this
in
and
go
in
excess
space
is
the
same
thing.
It's
just
like
different
phases
and
different
methods
are
exposed
with
the
native
native
yeah.
C
Maybe
it's
good
to
add
here
that
one
of
the
main
difference
between
the
lua
code
and
like
go
or
python
or
javascript
is
that
the
other
languages
run
out
of
process.
So
basically,
this
there's
another
process
running
next
to
the
kong
process
inside
the
same
container.
That
will
actually
execute
all
the
all
the
plugins,
but
it
does
mean
that
there's
some
overhead
involved
with
marshalling
all
the
data
in
and
out
of
that
process
and
that's
why
the
lower
the
lower
environment
actually
is
yeah.
B
C
So
here
we
are
with
20
codes
left,
which
actually
20
lines
of
code
left
would
actually
is
a
working
plugin.
This
thing
will
just
work.
It
won't
pass
the
test
anymore
because
we
removed
the
the
the
header
on
the
on
the
response,
but
this
in
itself
is
a
functioning
plugin
and
just
20
lines
of
code.
C
So
what
I
set
out
to
do
for
today
was
actually
to
go
and
create
a
plugin
that
does
a
very
minimal
authentication.
C
The
idea
would
be
we're
going
to
create
a
plugin
that
makes
an
request,
comes
in
it,
grabs
a
header
and
makes
a
request
to
a
remote
server.
If
the
remote
server
responds
with
200
okay,
the
request
is
allowed
if
the
remote
server
responds
with
anything
else,
we're
going
to
deny
the
request
we're
going
to
deny
access.
C
So
what
do
we
need
to
do?
First
thing
we
need
is
we
need
a
header,
because
when
we
get
in
the
access
phase
and
a
request
comes
in,
we
need
to
figure
out
like
what
header
do
we
need
to
grab.
So
if
we
look
in
our
schema,
we
can
see
that
we
already
have.
We
can
pretty
much
all
of
this.
We
can
leave
the
same.
We
had
a
request
header
and
let's
say
that
we're
gonna
rename
this
and
we're
gonna
name
this.
C
This
auth
header
and
we're
gonna
do
we're
gonna
miniath
named
after
our
plugin
for
the
default,
the
other
ones.
Are
we
going
to
need
them?
I
would
say,
probably
not
so,
let's
just
delete
those
and
then
we
should
be
good
to
go.
Is
this
still
like
complete
or
all
the
accolades
are
matching?
So
this
is
still
okay,
so
we
now
changed
the
default
schema
and
we
now
have
a
schema
with
a
single
header
name,
which
is
the
auth
header.
It's
called
mini
auth.
C
If
we
go
into
this
one,
the
first
thing
we
would
need
to
do
is
we
would
need
to
get
the
actual
headers.
How
do
you
know
where
you
can
find
headers?
That
is
what
you
find
in
the
con
documentation
conducts
reference
and.
B
C
C
C
Local
auth
header
is
kong
request.getheader
and
now
we
don't
need
to
find
the
host
header,
but
we
need
to
do
plugin
count,
dot,
auth
header,
because
that's
the
name
that
we
gave
in
our
schema
now.
If
there
is
first
thing
we
need
to
check,
like
is
the
remote
header,
or
did
we
even
get
one?
So
if
we
did
not
get
an
off
header,
then
in
lua
that
means
there's
a
nil
value.
It's
not
a
string.
This
is
a
nil
value
and
we
don't
get
an
auth
header.
C
B
B
If
the
id,
if
there's
id
that
can
understand,
like
law,
quote
very
well
and
suggest
you
some
of
the.
C
Unfortunately,
there's
no
there's
for
kong.
Specifically,
there
is
there's
not
code
completion
yeah,
but
that
is
yeah.
It
would
be
crazy
if
we
could,
as
some
somebody
actually
create
this.
So
here
we're
gonna,
see
we
can
just
create
a
con
response
exit
and
give
it
a
200
success.
Obviously
we're
not
going
to
do
that
in
this
case,
but
this
by
the
way
this
this
return
here
is
not
necessary,
because
if
you,
if
you
do
an
exit,
it
does
not
return.
So
the
code
ends
here.
The
code
flow.
C
It's
just
good
practice
that
you
actually
do
a
return
so
that
the
casual
reader
would
actually
know
like
hey.
The
code
is
terminating
here,
the
code
path
and
if
we
don't
have.
C
Gonna
say
a
403
android
8443.
We
don't
even
need
a
message,
but
we
can
say
a
message:
please
provide
all
details.
B
So
when
we
can,
we
also
like
attach
the
like
a
header
information
as
well.
For
example,
say
I
want
to
make
sure
that
people
know
that
this
is
actually
a
message
from
the
header
from
the
from
the
plugin
like.
What's
what's
the
what's
the
the
convention
of
reporting,
this
type
of
jazz,
for
example
like
when
this
error
appeared,
people
need
to
understand
why
maybe
someone
misconfigured
and
enabled
this
plug-in,
and
they
not
intended
to
what
would
be.
C
Yeah
yeah
there's
there's
two
sides
like
here:
you
can
see
the
the
actual
definition
of
of
the
function.
It
gives
status
code,
then
a
body
and
then
potentially
headers
that
you
can
send
in
this
case,
because
it's
an
authentication
plugin.
You
would
not
provide
too
much
details.
Typically.
B
It's
kind
of
like
conventions
like
if
it's
a
security
stuff,
if.
C
It's
security
because
you
don't
want
to
provide
any
attacker
with
like,
like
it's
typically
like.
If
you
do
a
password,
then
you
never
get
like
yeah.
Your
email
is
okay,
but
the
password
doesn't
match
because
then
you're,
giving
away
that
email
is
okay.
So
basically
you
say
this
password
email
combination
does
not
work
and
the
same
here
if
it's
authentication
provide
as
little
details
as
you
find
you
just
give
a
four
or
three
unauthenticated
and
that's
it.
So
probably.
B
B
And
we
can
do
even
like,
like
a
flip,
the
bird
emoji
to
be.
C
Yeah,
you
can
add
basically
this.
This
is
the
raw
body
that
is
sent.
So
you
can
add.
If
you
need
xml
type
output,
you
can
put
xml
in
there.
You
can
json,
you
probably
set
the
response
headers.
So
basically.
C
So
one
thing
we
did
not
touch
on
yet
is
how
do
you
debug-
and
this
is
actually
what
this
thing
is
for
analog
inspect?
You
can
actually
display.
C
Let's
move
that
here
and
we
could
actually
try
and
make
that
visible,
because,
typically,
when
we
do
things
like
this
now
I
have
to
go
and
do
a
split
screen
and
see
what
happens.
C
And
what
we
can
do
here,
because
I'm
now
in
the
same
directory
in
my
plugin
directory
again
and
a
very
helpful
command,
is
pongo
tail
and
pongo
tail
will
actually
will
find
the
running
kong
instances
that
you
have
and
it
will
actually
till
the
log
files.
So
in
this
case
we
can
see
here
that
we
have
output.
This
is
from
the
previous
run.
C
C
Okay,
so
I
had
moved
some
in
my
schema.
I
have
removed
some
fields
here,
but
in
the
entity
checks
that
an
entity
check
like
each
field
has
its
own
checks
like
in
this
case.
This
field
is
required
and
has
a
default
value,
but
sometimes
for
a
full
configuration.
You
also
need
across
different
fields.
You
need
to
validate
other
stuff.
So
in
this
case
here
in
the
template,
there
is
like
at
least
one
off.
You
must
at
least
provide
the
requester
or
the
response
header
and
the
request
header
and
the
response.
C
B
It
sometimes
not
a
referencing
fee.
This
is
something
that
comes
with
the
the
framework,
the
this
like
a
busted
framework,
or
it's
a
it's
a
part
of
the
checks
that
kong
does
this.
B
All
these
g-cells
do
you
sell
like
a
type
of.
C
Yeah
this
is
a
dsl
that
allows
you
to
configure
this
stuff
yeah,
but
now
I'm
referencing
fields
that
are
no
longer
there
and
that's
why
it
gives
me
the
error.
So,
let's
remove
that
as
well
and
give
it
another
try.
C
With
another
era-
oh
these,
no,
these
are
actually
now
it
runs,
but
the
tests
are
failing
and
you
can
see
that
the
unit
tests
which
actually
test
the
scheme
are
now
failing,
probably
because
they
use
the
same
fields
that
are
no
longer
there.
But
what
the
thing
was
about
is
that
we
now
see
in
this
run.
In
this
test
run,
we
can
actually
see
that
here
we
see
the
output,
and
now
I
have
to
make
this.
C
C
And
you're
wondering
like
what
is
the
data
that
I'm
getting
here?
How
can
I
check
what
is
going
on
under
the
hood?
This
is.
This
is
an
excellent
way.
Now
you.
B
Now
you
have
it
folks,
this
is
the
the
console.log
is
always
your
the
tool
for
for
debugging
stuff.
C
C
B
C
C
So
now
that
we
have
this
plugin
configuration
and
we
can
actually
I
already
deleted
it-
nope-
never
mind
so
this
one.
Let's
comment
it
out
for
now:
we're
not
using
it.
C
Yeah,
that's
that's
actually
true.
That
is
actually
true.
This
is
yeah.
It's.
I
don't
think
it's
a
very
common
convention,
but
you'll
get
used
to
it.
B
C
I
guess
so
now
we
have
a
we're
grabbing,
a
header
we're
getting.
A
C
Value
if
the
header
is
not
there,
we're
just
sending
in
four
four
four
three
unauthenticated
and
let's
see
what
we
can
write
a
test
that
actually
verifies
that.
C
So
if
we
look
at
first
off
schema,
we
have
a
field
auth
header
and
it
is
required
and
the
default
is
mini
off.
So
let's
look
at
our
specs.
C
C
B
C
Let's
see
if
we
can
see
this
distinct
thing,
we
completely
deleted
it.
So
that's
not
gonna
work.
So,
let's
try.
If
we're
gonna,
validate.
C
If
we
set
it
to
null,
basically
meaning
that's
the
difference
in
our
schema
here
we
say
required
is
true,
and
the
default
is
this,
but
it
doesn't
mean
that
you
can't
force
it
nothing
yeah
yeah.
So
if
you
set
it
to
mill
a
json
null
in
your
in
the
management
api,
you
would
essentially
tell
like
delete
the
value,
not
even
the
default
value,
and
that
is
what
required
is
true,
actually
prevents,
because
it
prevents
you
from
not
explicitly
specifying
a
null
value
and
not
providing
anything.
C
C
C
And
it
says
off:
header
required
field
missing,
that's
interesting,
because
this
is
the
test.
I
didn't
write
the
test
properly,
but
I
wrote
it
bad
on
purpose
to
make
sure
that
I
do
see
the
proper,
proper
error,
and
now
we
see
that
congress
responds
with
conflict.
Auth
header
required
field
is
missing,
that's
exactly
because
I
specified
a
null
so
to
fix
that
test.
C
C
C
B
C
Yeah
I
just
want
to.
I
just
want
to
ensure
that
if
it's
not
okay,
that
it
actually
does
fail,
yeah
and
one
once
I
know
that
the
test
is
proper.
I
update
the
values
to
make
sure
that,
and
now
we
see
that
it
actually
is
green,
and
this
means
that
we
actually
now
testing
that,
whatever
we
defined
in
the
schema
here
that
says
that
that
this
one
is
required,
and
it
has
a
default
value
that
it
actually
works
like
this.
So
typically
you'd
also
have
another
test
that
validates
that
the
default
failure
could
set.
B
Now,
before
we,
we
we're
running
a
little
bit
over
the
time
in
the
on
our
stream
before
we
disconnect.
I
really
want
you
to
show
some
of
the
pointers
how
they
can
interact
with
external
systems,
and
specifically,
I
think
that
you
mentioned
like
okay,
so
you
need
to
hit
some
other
service.
What
are.
A
B
Available
in
order
to
you
know
just
like
test
a
great
let's,
let's,
let's
see,
if
we
can
do
this
kind
of
like
hitting
the
service,
we
have
a
200.
B
Oh,
yes,
it's
a
very
good
pointer,
because
it's
also
you
can
also
show
how
we
can
install
a
dependencies
to
our
plugins
and
some
of
some
some
of
the
libraries
that.
C
C
C
That
makes
a
request
to
a
to
a
back
end
and.
C
Exactly
so
first
thing:
I
do
I'll
I'll
move
the
required
library
here.
So
http
is
required
to
be
like
this,
and
here
we're
gonna.
Do.
C
C
Yeah
so,
but
this
means
we
need
another
another
scheme
here,
because
we
need
a
url
to
be
defined
where
we
can.
C
C
A
C
C
C
C
Token
equals
dot
and
then
we're
gonna.
Add
the
alt
header
value.
C
A
C
And
if
the
request,
if
the
response
is
empty,
it's
a
nil
value.
Now
we
can
use
a
boolean.
If
not,
then
we're
going
to
say,
request
failed
with
an
error
and
we're
going
to
return
a
same.
C
Internal
server
error
because
we
don't
know
what
happened,
but
something
on
our
end
is
wrong
because
the
request
the
request
itself
failed,
we
didn't,
we
didn't
get
a
bad
status.
It's
just
that
the
request
failed.
The
connection
was
borked
or
whatever.
C
So
let's
do
this
and
then
let's
get
our
kernel.
Log
inspect
see
what
we're
getting
here.
C
And
then
see,
if
we'll
run
the
test,
what's
going
to
happen
now,
we
first
have
to
actually
write
a
test
in
this
case.
Obviously
I
think
it's
an
integration,
spec.
C
Interestingly,
this
just
sidestep,
but
this
is,
I
think,
an
important
one
if
you,
if
you're
wondering
about
the
test
helpers
and
how
they
work,
because
a
lot
of
those
are
not
on
the
kong
website.
C
But
again
there
is
pongo
to
the
rescue.
Pongo
has
a
command,
it's
called
docs,
you
can.
All
the
pongo
commands
also
have
a
help
option.
So
you
can
it's
easy
to
read
up
on
what
it
does
and
what
punkerdock
says
it
takes.
The
kong
test.
Helpers
renders
documentation
and
then
opens
it
locally,
oh
wow,
and
in
this
case
it's
very
quick
because
I
apparently
I
had
a
cached
version
here
but,
for
example,
the
call
that
we
had
in
our
test
helper
here.
C
A
C
It
has
documentation
of
how
it
works,
and
it
includes
good
examples.
This
one
goes,
for
example,
for
dns
fixtures,
so
you're
mocking
dns
records.
If
you
don't
want
to
create
an
external
dependency,
you
can
even
create
your
own
in
the
end.
Enginex
is
an
http
server.
So
if
you
need
an
http
server,
you
can
create
your
own
local
http
server
inside
nginx,
and
you
can
just
loop
the
request
to
the
local
instance
and
get
get
a
http
response
from
it.
C
Cool
yeah
yeah,
so
it
is
definitely
we
designed
this
because
originally
we
didn't
have
it
and
it
made
our
tests
slower,
because
all
the
tests
were
hitting
like
mock
bin
or
http
bin
and
at
the
same
time
any
network
failure
will
will.
B
C
That-
and
this
is
this-
may
make
made
the
test
a
lot
more
reliable,
but
it's
it's
there's
there's.
Even
there
is
an
existing
mock
one
inside
kong
that
we
will
be
using
in
the
normal
test.
C
C
That's
defined
inside
con,
exactly
as
I
just
explained
in
this
case,
what
we
do,
what
we
do,
we
inject
a
route
that
is
called
test1.com,
so
if
we
make
a
request
to
test1.com
we're
going
to
make
sure
that
we're
going
to
hit
this,
this
endpoint
second
thing
we'll
do
is
we're
inserting
a
plugin
on
top
of
the
route
with
this
id,
which
is
this
route,
and
with
this
configuration-
and
in
this
case
we're
gonna-
have
an
auth.
Url
is
gonna,
be
http.
C
C
And
so
we
need
a
this.
Is
the
one
for
status,
slash
200?
This
would
give
us
a
route
for
a
succeeding
test
yep
and
let's
do
another
one.
C
B
So
essentially
it's
we
can.
We
can
mock,
insert
the
fixture
for
particular
plug-in
configuration.
A
C
Yeah,
so
here
the
successful
one
is
test1.com
and
the
unsuccessful
one
is
test2.com.
So
now
we're
going
to
make
a
request.
Let's
first
clean
up
this
one
much
we
did
with
the.
C
C
And
we're
going
to
set
that
to
a
value.
The
reason,
by
the
way
that
I'm
I'm
using
this
syntax,
is
that
a
dash
is
not
a
valid
low
identifier.
So
we
need
to
push
it
in
wrappers
like
host,
is
written
down
below
here,
but
this
would
be
the
same
format
and
just
as
valid
it's
just
if
you
just
type
host,
it's
just
a
shorter
form,
but
it's
in
the
end.
The
same
thing,
many
others,
we're
gonna
said
we're.
C
Gonna
set
our
super
secret
in
here,
so
we're
gonna
make
a
request,
we're
providing
the
auth
header.
So
we
should
not
be
getting
a.
B
So
this
is
the
test.
This
is
the
test
where
we're
going
to
hit
the
request
with
the
test.
One
head,
the
url
that
will
be
essentially
represented
by
http
status,
200.
C
Yeah,
so
we're
going
to
hit
this
test1.com,
which
means
that
we're
going
to
hit
this
route
and
we're
going
to
hit
this
plugin
and
the
auth
url
is
making
our
request
go
to
hdbin
status.
200
the
request
from
the
gateway
to
the
backend
to
validate
the
authentication
is
going
to
be
so
it
should
give
us
a
200
in
return.
C
B
C
C
C
And,
and
where
is
the
status,
the
status
is
indeed
200,
because
we
said
the
auth
is
going
to
be
we're
going
to
slash
data
200
endpoint,
so
http
burn
does
as
it
promised,
and
it
returns
as
a
200..
C
C
This
is
also
a
good
thing
to
show,
because
the
assertions
we
use
in
the
tests
here.
B
Yeah
kind
of
like
aware
of
so.
C
And
the
next
thing
we
do
is
that
we
assert
that
a
request,
r,
which
is
not
the
is
actually
not
the
response,
but
the
request
that
is
echoed
inside
the
response:
r,
that
that
request
has
a
header,
hello,
world
and
the
nice
thing
about
these
assertions,
which
are
all
documented
in
the
same
documentation
that
I
showed
before
the
nice
thing
about
these
assertions
is
that
they
also
print
very
valuable
output,
because
actually
it
says
like
hey,
I
expected
this
header
hello
world,
but
I
didn't
find
it
and
then
it
actually
lists
all
the
ones
that
they
did
find.
C
So
if
you
make
a
small
typo,
you
can
very
easily
see
what
what
what
is
wrong.
C
See
that
that
our
plugin,
that
was
supposed
to
send
in
the
mini
auth
header
to
the
back
end
that
we
configured
with
super
secret,
we
can
actually
see
that
it
that
that
off
header
is
actually
here.
So
we
probably
better
now
change
our
assertion
to
actually
look
for
this
one.
C
So
this
assertion
tests
that
the
header
is
actually
there.
So
let's
remove
those
comments
because
they're
no
longer
there
and
then
the
final
part
is
that
we're
actually
gonna
validate
that
the
value
that's
in
the
header
is
actually
the
password
that
we
pass
in.
C
So
we
must
make
sure
that
we
actually
pass
in
the
same
value
that
we
get
from
our
client
into
into
the
the
request
to
the
back
end,
and
I
think
we
should
be
getting
to
a
point
where
it
might
actually
succeed.
B
That's
cool
all
right
so
reiterate,
so
we
showed
you
how
you
can
how
we
can
mock
basically
different
responses
in
different
requests
for
for
your
plugin,
and
you
can
inject
different
values
in
into
schema
of
the
plugin
right.
So
in
this
case,
we,
the
we
use
like
a
test,
one
dot
com
as
a
as
a
mock
route
for
a
valid
result.
A
C
Wanna,
what
I
personally
find
one
of
the
nice
things
is
that
it
keeps
everything
quite
close
together
like
the
mock
setup
and
the
tests.
They
essentially
belong
together
because
they
are
one
coherent
piece
of
data.
One
doesn't
work
without
the
other
and
if
you
exchange
one
without
the
other,
then
everything
will
fail.
C
So
here's
a
coherent
piece,
everything
stays
together
and
you
can
both
the
mock
data
that
you
define,
as
well
as
the
as
a
test
that
you
do
they're
in
the
same
place,
so
you
always
make
sure
that
it
works
wherever
you
run
them
it's
not
depending
on
the
environment.
I.
B
Think
this
is
this
is
where
we're
gonna
press
the
pause
and
we're
gonna
okay.
So
let's
hide
the
comments:
yep
yeah!
So
folks,
now
you
have
the
idea
how
you
can
implement
the
plugin.
You
can
always
ask
the
questions
either
in
in
the
forum.
You
can
ask
the
questions
in
github
discussions
for
for
this
hackathon
or
reach
out
to
me
directly,
and
I
will
point
you
to
the
to
the
right
the
place
and
leave
the
comments
in
this
video.
B
If
you,
if
you
think
this
was
useful,
at
least
it
was
definitely
useful
for
me
also
because
I
know
a
little
bit
more
about
the
this
framework
that
we
use
in
the
in
the
testing
and
the
writing.
These
things,
the
I
think,
with
the
with
the
off
process
pdks,
you
can
stay
with
the
frameworks
that
work
for
you
in
your
languages
of
choice.
B
You
know
you
can
use
whatever
libraries
here
is
more
kind
of
like
a
more
opinionated
and
more
everything
is,
is
close
together,
more
integrated,
so
you
have
a
you.
Have.
B
You
have
a
choice
to
to
do
this
and
I
really
appreciate
that.
I
found
the
time
and
joined
me
to
this.
Live
stream
today.
Learn.
C
A
lot
one
thing
would
we
I
don't
I'm
way
over
time.
I
know,
would
it
be
spending
a
couple
of
words
on
distribution
of
plugins
yeah.
B
I
I
think
it's
it's
it's
good.
If
you
can
talk
a
little
bit
about
this
as
well,
because
one
of
the
things
that
we
really
want
people
to
when
they
will
be
submitting
their
hackathon
results,
this
thing
needs
to
be
available
somehow,
and
you
know
for
easier
testing
things
and
like
play
around
things,
it
would
be
great
to
tell
them
like
okay.
So
you're
done
you,
you
do
your
your
development.
B
Let's
talk
about
how
you
distribute
the
plugins.
Do
you
need
a
you
need
a
vector
screen,
yeah
yeah!
Please
do
just
move
your
window
yep
exactly.
C
So
so
here
we
saw
in
in
how
we
write
the
test.
We
updated
the
unit
test,
we
updated
the
integration
test,
it
actually
test
the
full
flow.
Now,
once
you
have
everything
done,
then
there's
regards
to
question
like
okay.
How
am
I
going
to
get
this
thing
out
there
and
actually
get
it
into
my
image
where
I
actually
can
run
it?
This.
C
C
Here
we
already
discussed
the
rock
spec.
The
rock
spec
is
a
like
a
manifest
file.
It
determines
what
files
you
want
to
distribute
and
how
lure
rocks,
which
is
the
package
manager,
should
build
it.
We
go
quickly
back
to
this
to
the
rockstar
file,
which
is
here
we
can
see
here,
there's
some
overhead
here
that
defines
names
etc.
Locations
for
the
gate,
repo,
but
here
is
especially
for
lua.
C
If
it's
just
lures
there's
nothing
else,
no
c
code
that
needs
to
be
compiled
just
lower
files,
then
this
is
the
essence
of
what
it
does.
It
just
grabs
the
two
files,
the
handler
and
the
schema
this
case
where
you
have
variables
in
here
for
the
plugin
name.
But
if
you
have
your
standard
name
plug-in,
you
can
just
make
it
hard-coded,
and
these
are
the
two
files
that
you
need
to
dispute.
C
That's
all
there
is
essentially
that's
all
there
is
to
it.
They
need
to
be
in
a
specific
path.
So
what
you
see
here,
kong,
slash,
plugins,
slash,
plugin,
name,
slash
handler
and
schema.lua
and
that's
where
they
need
to
be
so.
If
you're
running
your
stuff
on
a
vm,
it
would
be
enough
if
you
just
place
those
files
among
the
con
and
distribution
files
within
the
plugin
folder.
If
you
go
into
a
bongo
shell.
C
C
Can
I
do
this
yeah
we
can
do
the
cd
slash
kong
plugin.
This
is
where
this
this
congress
plugin
folder,
is
the
mount
to
the
host.
So
this
is
the
same
folder
with
where
your.
C
Yeah,
so
this
is,
this
is
the
same
folder.
The
one
that
you
see
here
in
kong,
dash
plugin
is
the
same
one
that
we
see
here
on
the
left
with
with
this
contents
kong
dash
plug
in
this
mini
this
auth.
It's
the
same
simple.
C
C
And
if
I
look
in
there,
I
should
probably
see
my
handler
handler.lower
and
let's
schematable.
So
if
you
want
to
distribute
the
core
of,
it
is
get
those
files
in
the
right
place
and
then
you
can
use
them.
You
still
have
to
configure
kong.
You
have
to
tell
kong
like
also
load
this
plugin.
Besides
the
bundled
plugins,
you
need
to
load
this
one,
but
this
is
the
core
of
it.
Now
the
question
is:
what's
the
easiest
way
to
get
those
files
in
their
destination?
C
If
you're
doing
a
vm,
you
can
just
use
a
lure
rox
install
command.
I
used.
I
just
used
little
rocks
pack
a
little
rocks,
make
that's
what
you
do
from
the
source
repository
and
it
will
install
the
the
rock
spec
that
it
finds
here.
C
If
I
would
exit,
if
I
want
to
distribute
it,
and
I
want
to
pack
it
into
a
package,
I
can
use
pongo
again
and
I
can
do
a
pongo
pack.
Pongo
pack
will
use
under
the
hood.
It
will
start
the
container,
build
everything
and
under
the
hood
it
will
use
little
rocks
again
to
pack
it.
If
I
now
go
along
with
it.
I
can
see
that
there's
a
rock
spec,
but
it's
also
an
actual
rock
file,
and
this.
C
That
is
technically,
it
is
a
file
you
can
unzip
it,
and
then
you
will
find
the
contents
of
the
repository
in
there.
It
has
everything
in
there
and
this
rock
file
is
the
only
thing
you
need
to
distribute
because
you
can
install
that
file
from
pretty
much
anywhere.
C
So
if
I
go
into
the
shell
again
so
ls
slash
com
dash.
C
C
If
I
tell
it
to
install
that
one,
it
will
just
install
that
block
without
having
I
haven't
grabbed
for
source
repositories,
whatever
it's
a
zip
file
as
everything
in
there.
So
that
is
the
file
that
you
would
want
to
distribute,
probably
and
then
let
lu
rock
do
have
a
lifting
of
making
sure
that
the
files
actually
end
up
in
the
wrong
in
the
right
place
in
the
in
the
file
system.
C
C
With
kubernetes,
there's
and
docker,
that's
essentially
two
options:
option
one
is
use
a
config
map
that
maps
external
files
into
the
container
in
the
right
location,
which
technically
does
the
same
thing
as
it.
We
said
before,
just
making
sure
that
the
files
are
available
in
the
right
location.
That's
what
a
conflict
map
does
it's
easy,
simple
to
get
started,
but
if
you
have
more
than
one
plugin
again
good
get
unreal.
If
you
have
four
or
five
six,
we
have
customers
like
dozens
of
custom
plugins
that
becomes
very
hard
to
manage.
C
At
the
same
time,
a
drawback
of
that
one
also
is
that
docker
containers
are
intended
to
run
the
exact
same
code
everywhere
and
by
mapping
the
files
into
a
docker
container
you're,
actually
changing
the
executing
behavior
of
the
docker
container
right.
A
B
C
Let
me
open
a
new
one.
We
have
a
docker
repository
docker
kong,
which
holds
the.
C
C
C
B
C
Now
now,
how
do
you
version
the
result
resulting
image
of
those
four
in
going
on
there's
four
artifacts
going
in
there's
one
coming
out?
How
do
you
properly
version
that
that
final
image
and
that
that
definitely
takes
some
something.
C
B
Yeah
it
is,
but
this
is
kind
of
a
customized
thing
and
it's
whatever
organizational
versioning
strategy,
you
use,
probably
different
organizations,
will
have
a
different.
You
know
the
way
how
they
can
version
things
yeah.
Maybe
they
have
a
kind
of
like
umbrella
version
for
all
the
custom
plugins
if
they
update
one
plug
in
the
update
other
plugins
as
well.
If
they
work
together
and
things
like
that,
so
yeah.
A
B
And
we
we
cannot
solve
this
problem
for
you
as
a
as
a
vendor.
We
have
our
own
kind
of
like
strategies.
How
we
can
do
this
and
I
think
yeah.
A
B
The
consistent
versioning
is
always
a
interesting
task
to
to
tackle
and
and
work
with,
so
folks,
I
seriously
don't
know
if
we
can.
You
know
sure
we
show
you
whole
life
cycle
install
the
tooling
the
copy
template
play
around
with
the
with
the
tools
play
around
with
a
the
tests
invoke
external
service.
I
think
that
that
was
super
helpful
and
super
informative
stream
today
and
I'm
super
I
I
couldn't
do
this
alone
without
ice.
B
Obviously
you
know
the
thank
you
so
much
for
joining
me
today.
I
hope
you
had
a
good
time.
We
didn't
have
like
much
of
the
questions,
but
I
I
expect
many
people
to
watch
this
recording
and
provide
the
questions
in
in
the
comments,
and
we
will
get
back
with
the
some
of
the
new
episodes
of
coin
builders.
Maybe
next
week
next
week
join
us,
we
will
maybe
we
will
talk
about
api
ops
and
some
of
the
automations
around
like
how
to
use
clonk
in
in
the
bigger
sense.
B
Now,
there's
no
there's
no
reason
for
you
to
not
to
play
around
with
the
hackertone
and
not
build
something
cool
dice.
Thank
you.
So
much
for
being
part
of
clone
builders
with
this
thanks
for
having
me.
C
B
Always
always
a
pleasure
always
a
pleasure
to
to
have
you
and
with
with
this,
as
always,
my
name
is
victor
gamov
and
have
a
nice
day.