►
From YouTube: [Online Meetup] Mocking APIs with Kong and API Fortress
Description
In this call API Fortress talked about mocking APIs with Kong and API Fortress. You might want to mock APIs to build tests against them before the services are ready, to save money during service development, or to keep your development environments isolated. Learn how API Fortress uses Kong in their API mocking technology. Plus, see a demo.
Resources:
API Fortress logging plugin: https://docs.konghq.com/hub/apifortress/
Guest blog on Mocking APIs: https://konghq.com/blog/api-fortress-mock/
Docs for API mocking with API Fortress: https://apifortress.com/doc/mocking-services/
Join our next Online Meetup: https://konghq.com/online-meetups/
A
All
right,
it's
10:05,
so
I
think
we're
gonna
go
ahead
and
get
started.
Welcome
everybody
to
the
con
community
call.
This
is
a
place
where
con
community
can
hang
out
see
each
other's
work.
Gasp
questions
learn
from
each
other
and
stuff
like
that.
Today
is
February
12
and
we
have
Jason
from
API
fortress
here.
Who's
gonna
talk
a
little
bit
about
the
solution
that
they
built
for,
mocking
API
calls
and
why
you
would
want
to
mount
calls
how
you
use
it
and
how
they
used
come
to
make
this
possible.
A
But
before
we
jump
into
the
presentation,
I
was
actually
hoping
that
we
could
do
things
a
little
bit
differently
and
have
people
unmute
and
introduce
themselves
and
say
hi.
First,
we
did
this
on
the
first
call
and
I
think
it
was
great,
so
I'd
love
to
learn
about
who
you
are
and
what
you
do
so
I'm
gonna
start
with
Hanna's
and
she's
right
below
me,
Hanna
say:
hi:
okay,
hello,
everyone.
A
E
A
F
Hi
guys
my
name's
Jay
it's
90
days,
I'm,
the
sales
engineering
lead
at
API
fortress
and,
if
you
bear
with
me
for
just
a
second
I,
will
get
us
rolling.
So
first
I'm
gonna
share
one
of
my
screens.
You
should
see
that
same
background.
You
saw
before
because
keynote
can
be
kind
of
a
pain
and
I'm
gonna
go
ahead
and
get
rolling
here,
and
can
everyone
see
that
first
slide?
You
should
see
something
that
says:
API
fortress
mock,
recording
with
calm.
Yes,
we
see
it.
Thank
you
fantastic!
F
So,
as
I
mentioned
hi,
my
name
is
Jason
ITD's
and
the
sales
engineering
lead
with
API
fortress
and
today
we're
gonna
take
a
look
at
how
API
fortress
utilizes
Kong
in
order
to
record
mock
endpoints.
So
in
order
to
kind
of
get
there.
The
first
thing
that
we're
going
to
take
a
look
at
is
what
API
mocking
means
and
kind
of
some
of
the
use
cases
and
pitfalls
therein.
F
Then
we're
going
to
take
a
look
at
how
Kong
helps
API
Fork
just
solve
a
couple
of
those
pitfalls
and
then,
finally,
if
we
have
a
little
bit
of
time,
we
might
take
a
brief
look
at
API
fortress,
but
before
we
do
that,
just
like
API
for
Chris
would
just
like
to
thank
Kong
for
kind
of
bringing
us
into
a
community
crawl
and
kind
of
letting
us
meet
the
community
at
large.
So
thank
you
so
much
common
with
that
being
said,
let's
go
ahead
and
move
ahead.
F
Now,
if
we
create
multiple
simulated,
API
endpoints,
we
can
then
kind
of
MIT
these,
together
into
you,
fully
realize
the
mock
environments.
So
we
can
simulate
entire
systems
entire
architectures,
and
then
we
can
take
those
kind
of
mock,
architectures
and
mock
endpoints
and
expose
them
and
make
them
accessible
to
the
rest
of
our
team
and
just
to
kind
of
give
you
an
idea
of
what
that
looks
like
an
API
fortress.
This
is
a
screenshot
of
our
marking
system,
which
we'll
be
taking
a
closer
look
at
a
little
later
in
the
presentation.
F
F
So
the
first
kind
of
big
thing
that
we
see
in
terms
of
use
cases
for
mocking
is
that
when
we're
talking
about
staging
environments
in
dev
environments
and
as
a
testing
platform
we
most
frequently
are
some
api's
are
not
available
in
internal
environments.
Now
this
can
relate
to
you
attempting
to
do
things
like
integration
testing,
from
an
API
perspective,
where,
if
we
don't
have
access
to
those
API
endpoints
in
those
developer
environments,
then
we'll
have
a
lot
of
trouble
actually
fully
realizing
those
integration,
workflows
and
that's
kind
of
what
we're
talking
about
here.
F
So
test
environments
may
not
be
able
to
reach
integrated
external
ap
is
another
kind
of
popular
use
case
that
we
see
somewhat
frequently
is
that
some
API
endpoints
have
what
we
refer
to
as
a
cost-per-click.
So
if
the
team
is
integrating
with
a
service
that
costs
actual
money
in
order
to
hit
when
you're
in
that
kind
of
development
phase,
you
don't
necessarily
want
to
be
spending
money
on
hitting
those
endpoints.
F
So
by
mocking
that
sort
of
endpoint
and
kind
of
using
more
static
responses,
you
can
do
meaningful
integration
testing
without
incurring
that
sort
of
cost
and
then
kind
of
the
third
and
I
guess
completing
the
triumvirate
of
popular
use.
Cases
that
we
see
would
be
just
that
some
internal
services
are
not
ready
yet
so
in
the
age
of
micro
service
architecture,
we
frequently
see
you
know
one
team
working
on
a
micro
service
and
another
team
working
on
micro,
service,
B
and
sometimes
versions
get
out
of
sync
in
terms
of
development
and
micro
service.
F
A
may
need
to
refer
to
micro
service
B,
which
has
not
completed
an
incoming
update
or
something
of
that
nature.
So,
in
order
to
kind
of
solve
that
problem,
my
teen
a
can
mock
the
expected
response
of
Team
B
and
complete
their
integration
testing
as
they
go
so
now
we
know
the
what
and
the
why?
What
are
some
of
the
problems
of
mocking?
F
So
there
are
a
number
of
I
suppose
not
necessarily
problems,
but
issues
that
we
may
face
when
we're
trying
to
create
kind
of
a
meaningful
mock
environment
and
the
first
one
is
kind
of
the
issue
of
localization
versus
kind
of
a
cloud-based
solution.
So
localized
mocking
is
not
necessarily
collaborative,
so
the
end
points
are
only
going
to
be
available
on
the
machine
hosting
the
actual
mock
server,
and
unless
that
service
is
exposed,
they
will
only
be
available
to
that
specific
machine.
F
Another
kind
of
pitfall
that
we've
faced-
and
this
is
specifically
what
kong
has
done-
a
lot
to
kind
of
help
us
solve
is
the
fact
that
the
manual
creation
of
mock
endpoints
can
be
extremely
time
consuming.
So
creating
kind
of
a
simple
JSON
object
is
very
straightforward.
We're
going
to
look
at
that
in
just
a
moment,
but
creating
more
kind
of
complex
kind
of
closer
to
the
real
world.
Mock
responses
can
actually
be
quite
difficult,
so
I
guess
the
next
logical
question
would
be
how
does
calm
fit
into
this
equation?
F
Api
fortress
uses
con
to
proxy
API
endpoints
record
those
endpoints
as
mock
endpoints
switch
between
mock
and
live
responses
which
we're
not
going
to
actually
look
at
in
the
demo
today,
but
is
a
feature
that
we
have
and
log
API
traffic,
both
with
the
mock
endpoints
and
we
actually
do
leverage
Kong
and
another
part
of
a
platform.
So
long
to
log
live
API
traffic,
so
in
terms
of
our
workflow
we're
going
to
start
with
an
endpoint
to
be
mocked.
F
What
we
just
spoke
about
in
that
workflow
that
we
just
looked
at
here's
API
fortress
kind
of
living
in
the
box,
that
it
lives
in
I'm
right
in
the
middle,
and
we
have
our
HTTP
client
over
to
the
left.
So
this
could
be
anything
from
curl
to
HTTP
to
any
other
number
of
systems
that
can
allow
us
to
send
HTTP
requests
and
we're
going
to
send
those
requests
through
comm
we're
gonna
proxy
endpoints
of
so
proxy.
F
So
that's
all
really!
That's
all
well
and
good
in
terms
of
theory,
but
I
think
we'll
really
start
to
kind
of
make
sense
once
we
jump
into
the
demonstration.
But
before
we
do
that,
as
this
is
a
community
call,
I
wanted
to
pause
and
see
if
there
were
any
kind
of
questions
on
anything,
we've
touched
on
so
far.
A
A
A
F
So
can
everyone
see
my
screen
again?
Yes,
we
can
okay,
terrific.
So
what
we're
looking
at
here
is
the
API
forretress
mocking
interface.
This
is
where
we
can
create
our
mock
endpoints
view
our
mock,
endpoints
and
grab
the
links
for
a
mock
endpoint.
So
what
I'm
going
to
do
is
I'm,
just
gonna
kind
of
create
a
very
simple
demonstration,
mock
endpoint,
so
I'm
gonna
call
it
demo
and
our
route
is
gonna,
be
slash,
API,
slash
Kong!
This
is
a
locally
running
instance,
so
everything's
based
out
of
the
host
file.
F
F
But
up
here
in
the
corner,
we
see
Kong
demonstration,
so
I've
created
a
mock
right,
but
this
is
not
really
what
I'd
refer
to
as
a
meaningful
mock
and
it's
a
super
simple
example,
and
thanks
to
Kong
we're
able
to
kind
of
create
much
more
meaningful
mocks
in
about
as
much
time
and
we're
going
to
do
exactly
that
right
now.
So
the
interface
for
API
fortress
mock
recording
is
this.
It's
actually
performed
mostly
through
the
command
line.
F
So
the
upstream
URL
is
demo
API
data,
API
fortress
comm
and
that's
the
demonstration
API
that
API
fork
is
hosts
on
its
servers
and
we're
hosting
it
through
comm
as
proxy
demo
API
that
API
fjj
cocom,
which
is
my
locally
mounted
instance
of
api
fortress.
That's
actually
getting
sent
to
the
instance
itself
and
8001
is
where
kong
is
currently
listening.
So
kong
has
become
in
this
situation
a
part
of
our
micro
service
architecture
acting
as
a
gateway,
so
I'm
gonna
hit
enter
and
we
get
a
whole
bunch
of
output
here.
F
The
important
output
that
I
need
is
actually
this
ID
right
here,
so
I'm
going
to
copy
this
ID
and
I'm
going
to
paste
it
into
the
next
request
that
we're
gonna
send
in
and
then
I'm
gonna
throw
that
request
and
this
one's
a
little
bit
more
complicated.
So
what
I'm
actually
gonna
do
is
I'm
gonna,
clear
the
screen.
First
Jason.
F
I'm,
sorry,
so
what
that
ID
specifically
refers
to
you
know
what
that's
a
great
question
and
I
can
give
you
a
better
answer
than
actually
explaining
it
like
that.
I'm
actually,
gonna
make
another
call
to
an
endpoint
that
will
reveal
all
of
the
endpoints
to
be
currently
approxi,
so
the
ID
to
answer
your
question
in
a
shorter
way
that
ID
is
the
ID
of
the
proxy
route
that
we
just
created
in
comm,
and
so
we're
gonna
go
ahead
and
take
a
look
at
all
of
those
currently.
F
So
here
we
go
so
I
just
sent
a
request
to
the
kong
instance
asking
it
for
a
list
of
all
the
currently
existent
proxies.
So
before
we
started
this
demo,
I
went
ahead
and
cleared
everything
out.
So
here
we
have
this
proxy
route.
We
can
see
its
upstream
URL
is
demo
api
than
api
for
curse.
Comm.
The
host
is
proxy
demo
api,
the
api
fjj
cocom.
So
that's
how
I
can
actually
hit
this
proxy
route,
the
name
which
is
literally
just
like
a
canonical
name.
Demo
api
and
the
ID.
Is
this
hash
here?
F
So
I'm
going
to
grab
this
hash,
I'm
going
to
paste
it
into
another
call,
and
what
this
call
is
actually
specifically
designed.
You
is
to
tell
the
the
Kong
proxy
to
turn
on
the
API
fortress
extension
or
plug-in
rather
for
this
specific
route.
So,
basically
we're
going
to
turn
this
from
a
regular
proxy
without
into
a
proxy
route
that
is
able
to
record
for
API
for
Chris
mocking.
Does
that
answer
your
question?
F
F
Sorry
and
great
question
by
the
way
super
important
okay
bear
with
me
for
one
sec:
let's
grab
this
ID,
let's
copy
it.
Let's
drop
it
into
our
route
here,
okay,
so
I'm
going
to
throw
this
into
a
CRO
request.
Okay,
so
there's
a
lot
going
on
here.
But
what
really?
What
really
bears
mentioning
is
that
this
specific
API
call
is
going
to
allow
us
to
turn
on
that
fortress
HTTP
log
extension,
which
is
going
to
ultimately
allow
us
to
send
requests
to
that
proxy
and
have
them
be
recorded.
F
F
F
So
I'm,
making
an
all
products
call
from
the
demo
API
that
we
proxied
and
I'm
sending
a
header
with
it,
which
is
the
expected
API
key
of
the
demo.
Api
I'm
doing
this
with
HTTP
just
so,
we
can
kind
of
see
a
more
colorful
response,
so
I'm
gonna
hit
enter
and
here's
our
response.
So
this
is
the
actual
response
body
that
we
expect,
and
this
is
the
response
of
the
actual
proxy
itself.
But
now,
if
we
jump
over
to
API
for
just
mocking.
F
We
actually
have
this
proxy
route
now
pushed
in
as
a
mock
and
if
I
click
into
this,
our
routing
is
also
separated
out
intelligently
and
I've
got
my
full
response
body
here.
So
if
I
actually
grabbed
this
route
and
throw
it
into
a
new
tab,
because
it's
a
get
request,
I
actually
have
a
fully
realized
mock
of
this
specific
route,
and
this
is
super
exciting
because
it
means
we
can
stand
up
really
meaningful
kind
of
mock,
API
endpoints
in
very
short
order,
and
to
kind
of
drive
that
point
home.
F
Let's
go
ahead
and
create
a
couple
more
essentially
with
the
same
route.
So
I
know
that
my
product
endpoint
has
individual
products
in
it
too.
So
those
are
routed
by
adding
IDs
onto
the
end
of
each
call.
So
I'm
going
to
go
ahead
and
hit
number
one.
Let's
hit
number
two
and
then
let's
hit
number
five.
F
So
now,
we've
made
those
other
calls
and
we're
throwing
those
through
that
proxy
brow.
If
we
go
back
over
to
API
fortress
and
refresh
the
page
and
jump
back
into
the
sprout,
I
now
have
one
two
and
five
all
recorded
as
mock
successfully,
and
this
is
all
at
this
point
effectively
automated
by
the
platform
and
I
can
hit
any
of
these
mocks
and,
more
importantly,
anyone
who's.
In
my
my
server
environment,
where
API
for
Chris
is
deployed
as
an
on-premises
product
is
also
able
to
hit
any
of
these
mock
endpoints.
A
F
Actually,
that's
a
really
great
question,
because
the
the
plugin
is
doing
a
number
of
things
in
this
case,
so
you're
right
in
so
far,
you're
actually
right
in
both
cases,
I
think
both
your
your
specific
in
your
hypothetical,
because
the
plug-in
is
yes,
what's
actually
pushing
to
API
fortress,
but
it's
also
doing
some
logging
for
us.
So
if
we
actually,
we
can
open
a
logger
and
Kong
is
also
handling
this
functionality
for
us
as
well,
where
it's
logging
all
of
the
calls
that
are
made
to
these
mocks.
F
B
Yeah
I
mean
I.
Guess
you
mentioned
that
there
is
a
pain
point
is
integrating
for
external
services
in
terms
of
say,
I've
been
terms
of
the
money,
however
I
think
like
any
any
of
those
services
should
have
like
some
test
environment
which
you
could
integrate
with,
but
at
the
same
time
the
endpoints.
Usually
you
know
they
don't
change
much,
so
you
might
have
some
pre-defined
like
integration
mocks
for
those
services.
I
understand.
F
A
I
was
gonna,
actually
ask
you
about
your
experience,
building
the
plug-in
itself
and
building
the
platform
like.
Were
there
things
about
Kong
when
you
were
trying
to
build
the
integration
that
could
have
been
better
or
like?
Did
you
have
a
pretty
easy
time?
Did
you
take
a
look
at
the
plug-in
development
kit
and
stuff
about
kind
of
your
process
around
that
so.
F
From
personal
perspective,
I
I
do
do
development
work
for
API
fortress,
but
this
specific
plugin
was
actually
handled
with
somebody
else
on
our
team.
Now,
I
am
involved
in
kind
of
the
follow-on
to
that.
So
what
we're
actually
looking
at
doing
is
kind
of
extending
this
functionality
a
little
bit
with
command
line
tool.
F
So,
as
you
guys
could
see,
you
know
we're
kind
of
sending
naked
HTTP
requests
at
current
to
the
proxy
and
we're
gonna
try
and
wrap
that
up
in
a
command
line
tool
to
kind
of
make
that
a
little
neater,
but
in
general
the
development
process
is
actually
very
friendly,
at
least
as
far
as
you
know,
I'm
aware
and
kind
of
was
involved
with
it,
but
the
development
process
and
the
tool
itself
has
been
very
it
kind
of
checks,
all
our
boxes.
It's
a
powerful
tool,
that's
very
easy
to
integrate
with.
F
A
Alright
cool
so
now
we
have
I
had
on
the
agenda
and
open
agenda
section,
which
is
basically
just
if
anybody
wants
to
talk
about
anything
or
bring
anything
up.
Has
any
questions
about
how
kong
development
is
going.
The
kongamato
patch
releases
or
anything
like
that
feel
free
to
either
unmute
or
chat
them
in,
and
if
we
don't
get
anything,
we
can
give
everybody
a
chunk
of
time
back.
C
C
So,
for
that
reason
the
adoption
is
gradual
and
that
was
totally
expected,
but
as
we
get
more
feedback
like
the
it's
normal
that
the
patch
releases
keep
coming
as
we
are
like
ironing
out
like
the
rough
edges
and
things
like
that,
so
the
patch
releases
are
essentially
for
stability
on
only
we
are.
We
are
using
semantic
versioning.
So
an
eerily
is
like
one
point,
zero
point:
X.
C
It
does
not
introduce
any
like
breaking
changes
or
incompatible
features,
so
they
should
all
be
like
a
drop-in
replacement
and
they
have
no
migrations
either,
and
so
it's
it's
a
very
smooth
transition.
So
it's
essentially
that
it's
it's
bug
fixes,
while
in
parallel
we
keep
our
work
going
on
1.1,
which
is
good
next,
like
minor
release
in
the
sequence
which
will
introduce
new
features
but
still
not
break
any
of
the
stuff
that
was
introduced
in
1.0,
sweet.
B
C
Yeah,
what
I
can
say
is
that
yeah
we
have
that
on
the
radar
and
in
at
the
same
time,
like
that's
like
that.
That
depends
on
on
lots
of
components
so
like
the
support
from
our
from
the
stack
that
were
that
were
built,
int
and
but
oftentimes.
The
stack
that
we
are
built
up
on
has
progress
because
of
us
because,
like
essentially
like,
we
are
sponsoring
the
development
of
some
components
and
things
like
that.
So
so
yeah
that
that
we
have
that
on
the
radar.
A
B
A
C
Yeah,
okay,
all
right,
so
those
great
two
great
questions
from
someone
who's
very
much
in
tune
with
what's
going
on
in
our
github
repos.
So,
yes,
we
are
hard
at
work
with
the
Cardiff
config
stuff.
Some
PRS
have
already
popped
up,
and
yes,
that's
a
that.
That
is
that
it's
like
in
the
immediate
horizon,
so
we
had
like
we
made
the
RFC
messages.
Therefore,
to
get
some
some
community
feedback
on
that
I
still
well.
I've
been
had
I've
been
hard
at
work.
C
Coding
and
I
haven't
like
gotta
run
route
to
get
back
to
actually
like
we're
flying
to
all
of
the
feedback
we
got,
but
the
feedback
was.
It
was
very
much
appreciated,
so
so
yeah,
that's
that's
a
sign
that
this
is
definitely
coming.
The
support
for
the
clarity
of
config
and
using
it
like,
like
both
as
a
way
to
import
stuff.
B
C
And
running
on
DB
list
mode
like
there
I
guess
you,
if
you,
if
you
peek
at
our
branches
in
the
live
loop,
oh
and
the
source,
you'll
see
that
there's
ongoing
work
on
that.
We
learned
the
second
question
whether
the
work
that
bungle
like
mr.
bungle,
which
is
a
are
for
developer
and
up
with
Alvin.
Sorry,
no
yeah,
so
yeah
many
of
us
in
court,
how
they
we
have.
They
have
been
working
towards
like
router
improvements.
I
know
that
pop
rocks
was
also
sent.
Some
stuff.
C
Cheapo
has
and
some
stuff
Apple
has
sent
some
stuff,
and
since
this
is
like
super
critical
I
think
we
all
need
to
sit
down
and
like
decide
a
path
forward
for
that
and
like
exactly
like,
which
of
like
which
which
of
the
bits
and
pieces
are
going
to
be
merged
into
core
like
Jeremy.
Your
feedback
on
that
on
this
stuff
has
been
like,
like
super
precious
for
to
help
us
get
a
clear
picture
of
the
impact
of
those
changes
so
yeah.
So.
B
C
C
A
Totally
different
topic:
is
there
a
Kong
summit
planned
for
this
year?
There
is,
we
are
in
the
planning
stages.
Now
we're
gonna
put
out
a
formal,
CFP
I
think
in
a
couple
of
months,
and
we
would
love
it.
If
you
guys
all
submitted
awesome
talks,
we're
really
excited
about
it.
We
don't
have
the
date
lock
down
yet
I
believe
we're
looking
at
the
fall,
and
we
will
definitely
keep
you
posted
I'm
really
stoked
about
it.
E
Sure
so
I
have
been
for
the
most
part,
happily
using
the
Kong
ingress
controller.
Recently
very
cool
thing
to
use,
but
so
the
the
first
question
is:
is
that
well
we're
running
into
some
issues
where,
when
we
configure
our
back-end
services
to
be
HTTP
services,
it
appears
that
somewhere
in
between
the
actual
registration
of
the
ingressive
and
actually
writing
those
two
or
calling
the
bit
kong
api
from
the
ingress
controller.
E
Image
is
actually
named
base
image
and
I'm
just
wondering
if
there
are
any
specific
build
requirements
for
that
or
if
it's
just
kind
of
a
fairly
straightforward
go
application
I'm
just
starting
to
get
into
that.
So
I
might
be
able
to
answer
some
of
these
myself,
but
I
figured
I'd.
Ask
anybody
here.
That
might
know.
A
I,
don't
actually
know
the
answer
to
those
and
Harry
who
you're
probably
used
to
having
answer
all
of
your
questions
about
the
best
controller
has
been
in
India
for
like
two
three
weeks
a
month,
but
he's
getting
back
like
tomorrow,
I
think
which
we're
all
so
excited
about.
So
I've
been
seeing
your
questions
come
through
and
I'm
like
ooh
I.
Don't
want
to
take
a
guess,
because
I
know
that
Harry
is
going
to
come
back
and
I'll
probably
not
be
correct.
A
E
E
Okay,
thank
you
so
much
that
helps
and
so
I
don't
know.
If
anyone
else
has
run
into
this,
where
the
backend
default
GTP,
and
I
don't
think
it
it's.
You
know
as
I've
been
using
the
ingress
controller,
it's
really
pretty
cool
because,
like
if
you
upload
a
certificate
to
kubernetes
and
you
go
check
the
certificate
and
data
store
in
Postgres
or
cassandra,
whichever
you
use,
it
actually
automatically
imports
all
those.
It's
really
cool
how
this
thing
works,
but
anyways
I'm
not
sure
going
with
that.
E
But
that
hope
that
will
help
me
with
being
able
to
what
I'm
going
to
do
is
I'm
going
to
go
in
and
change
the
default
values
for
services
to
be
443
and
HTTPS
and
I
think
that
all
six
are
problems
for
us,
but
I'm,
just
I,
don't
know
how
many
people
are
using
the
ingress
controller
in
kubernetes,
but
I
would
imagine
that
other
people
would
be
having
this
issue,
but
maybe
they're
not.
But
thank
you
that
helps
yeah.
D
I
know
it's
a
newer
kind
of
way
to
utilize
Kong,
but
it
is
getting
picked
up.
We
do
see
a
more
chatter
about
it
in
other
slack
channels
like
I,
know,
there's
a
Kong
channel
on
hang-ups
and
a
Kong
channel
in
kubernetes,
and
a
lot
of
the
questions
I
see
in
there
are
related
to
ingress
and
kubernetes.
Obviously
so
Oh
awesome.
A
E
A
All
right
so
I
think
we're
gonna,
give
everybody
15
minutes
back
have
a
great
month.
If
you
are
interested
in
presenting
some
work
on,
the
community
call
I,
think
you've
done
with
Kong
or
a
plugin,
you've
built
or
I,
don't
know
a
project
that
you're
proud
of.
Please
let
us
know
we're
always
looking
for
presenters
and
we'll
see
you
next
month.
I
think
the
next
call
will
be
on
March,
12th
I.
Believe
it's
the
second
Tuesday
of
the
month.
Talk
to
you
later
thanks
guys.
Thank.