►
From YouTube: Managing Kong Workflows From Slack: Your API Butler for the Enterprise at Your Commands
Description
Learn more about Kong: https://bit.ly/2I2DypS
Slack is a natural gateway to API transformation because it solves the inherited complexity of enterprises fast-changing their work and communication methodologies. The challenge is to accelerate and democratize access to microservices, enabling an ecosystem based on cross-pollination, distribution and transparency while avoiding duplication of effort. Efficient collaboration and communication are the core of this process. The developer community needs a tool which allows them to operate these workflows while simplifying access to traditionally complex processes. Slack has then become the saving grace for many development teams in a remote-first world.
In this Kong Summit 2020 talk, the audience learned:
- How to set up Ops to seamlessly integrate with Slack
- How to create an API based on a pre-defined template within Slack
- How easy an API registration in Kong can be done via Slack
- How to bring command, pipeline and services together seamlessly
- Allow for transparent and analytic feedback loops within Slack
- How to discover APIs in an easy and immediate way
A
Hello,
everyone
and
welcome
to
my
talk.
I'm
super
excited
to
be
here
at
kong
summit
digital
this
year
and
I
am
luca
I'm
the
vp
of
engineering
of
cto.I
and
I'm
today,
I'm
gonna.
Take
you
through
a
journey
of
managing
kong
workflows
from
slack.
We
are
going
to
see
how
to
create
an
api
buffer
for
the
enterprise
at
your
commands
right.
So,
let's
get
started.
A
So,
let's
start
with
this
talk,
so
I
am
luca
maraschi,
as
you
can
hear
from
my
accent,
I'm
italian
and
I'm
the
vp
of
engineering
at
cto.I
are
in
vancouver,
canada,
and
I
just
give
you
a
brief
overview
of
my
past
experiences
just
to
contextualize
this
whole
journey
that
we're
gonna
walk
together
a
few
years
ago.
I'm
not
gonna.
Take
you
to,
since
I
was
six
years
old,
I'm
just
taking
the
few
years
back.
A
I
worked
in
consultancy
and
in
enterprise,
and
I
also
most
recently
was
the
chief
architect
at
talos
digital.
So
I
saw
basically
the
enterprise
space
from
jumping
from
one
fortune
500
to
another
to
be
inside
of
a
large
organization
right
and
most
recently
after
experiencing
all
these
different,
very
interesting,
challenging
challenges.
I
took
this
opportunity
and
joined
cto
ai,
a
startup
right.
They
seem
so
different,
but
they
are
also
so
similar,
these
two
environments.
A
So
what
I?
What
I
experienced,
what
I
saw
with
my
eyes,
was
the
old
digital
transformation
journey
right
and
within
this
journey
we
we
all
know
how
everything
started
right.
We
started
from
the
famous
monolith
right
and
this
monolith
evolved
into
microservices,
and
you
know
we
are
already
at
consummate
because
one
way
or
another,
we
are
working
in
the
api
and
services
space
right,
but
this
transformation
actually
went
beyond
the
the
simple
you
know:
services
and
api.
A
This
new
way
of
interpreting
data
in
this
large-scale
ephemeral
and
highly
distributed
way
right,
but
the
real
transformation
happened
beyond
the
technology
right,
so
we
saw
that
the
organizations
and
the
teams
people
changed
from
working
in
silos
to
a
federated
model
right
and
as
we
are
all
experiencing
as
part
of
this
crazy
2020
distribution
became
one
of
the
core
attributes
of
this
new
phase
right.
So
the
acceleration
in
this
transformation
was
escalated
this
year
with
a
highly
distributed
nature
of
new
organizations
right.
A
So
we
saw
basically
the
system
becoming
from
a
huge
single
monolithical
unit
to
fragment
the
more
atomic
and
independent
units
and
the
eternal
question
in
all
this
journey
right,
because
we
are
all
in
one
way
or
another,
as
developers
as
architects
as
executives
right
having
this
focus
in
this
journey.
That
is
how
can
we
modernize,
while
accelerating
right,
because
we
just
said
that
the
distribution
requires
a
higher
degree
of
coordination
right.
So
we
have
a
degree
of
complexity
added
to
this
system,
and
so,
but
how
can
we
accelerate
and
the
core
is?
A
They
are
distributing
themselves,
so
they
are
spreading
across
different
areas
of
the
organization,
different
geographical
areas
right
and
so
now
the
the
real
challenge
is:
how
would
we
cross-pollinate
knowledge
because
people
before
they
were
sitting
next
to
each
other?
Now
they
distribute
more,
and
especially,
how
can
we
coordinate
asset
reusability,
which
is
basically
the
drive
of
the
all
kpis
for
many
of
the
transformation
journeys
and
at
the
at
the
center
right?
There
is
this
requirement
to
build
once
and
reuse
everywhere.
A
While
actually,
we
need
to
take
care
of
reducing
the
logistical
complexity
now
imagine
that
the
whole
journey
is
based
on
a
feedback
loop
right,
so
we
we
go
from
concept
to
market
we
validate
with
the
market.
The
market
feed
back
into
this
feed
the
feedback
loop
and
the
cycle
restarts
right.
So
the
logistical
complexity,
from
from
going
from
a
to
b,
needs
to
be
solved
right
and
in
a
frictionless
way,
and
how
do
we
do?
It
is
by
simplifying
and
equally
distribute
operational
workflows
right
because
we
were
used
to
a
system
right.
A
It
was
based
on
this
very
tightly
coupled
interaction
and
iteration,
so
the
operational
flow
was
very
kind
of
humanly
driven,
and
now
we
are
decoupling
them
and
at
the
core.
We
need
to
simplify
and
equally
distribute.
Why?
Because,
if
you,
if
you
think,
and
probably
this
image
easily
represent
what
I'm
trying
to
to
describe
right?
So
if
we,
if
we
look
it
from
the
inside,
every
everything,
looks
as
a
unit
right,
but
if
we
take
it
from
10
000
feet.
A
If
we
go
outside
of
this
atmosphere
and
look
at
the
whole
ecosystem,
we
will
see
that
actually,
there
is
a
high
degree
of
coordination
needed
and
all
these
pieces
that
are
moving
right.
They
need
to
make
sense
and
need
to
be
equally
distributed
and
basically
the
the
challenge
that
we
still
have
is.
How
do
we
discover
right?
Because
once
again,
the
more
we
fragment
the
more
we
distribute?
Imagine
things
are
getting
very
distant
very
very
far
from
each
other.
A
A
We
all
agree
with
the
must
have.
We
must
have
documentation,
however,
documentation
lacks
of
all
the
value
that
interactions
are
bringing
together
right.
So
imagine
a
group
of
people
together
discussing
about
a
problem
right
documentation
needs
to
be
hydrated
with
this
feedback
needs
to
be
maintained,
needs
to
be
constantly
validated
and
reconcile
with
people.
Why?
Because
interactions,
they
are
always
happening
in
a
very
synchronous
way
and
as
soon
as
we
need
to
reconcile
or
con
or
validate
documentation,
it
becomes
asynchronous.
A
So
we
add
again
more
complexity
to
keep
consistent
and
coordinated
documentation,
and
so,
as
we
all
know,
because
we
are
all
have
been
victim
one
way
or
another
of
meetings
right,
we
go
into
meetings
to
discuss.
We
need
meetings
to
discover,
we
need,
we
go
to
meetings
to
ask,
but
meetings
are
expensive
because
they
cost
time
right
and
if
we
think
time
is
the
constant
that
that
continuously
drives.
You
know
the
the
kpi
for
acceleration
right.
We
if
we
could
stop
time,
we
would
all
accelerate
a
lot
right.
We
would
all
do
this.
A
We
would
all
build
an
api
in
no
time
we
would
all
deploy
in
no
time.
Unfortunately,
time
is
there
with
us,
and
so,
if
you
look
again
at
10
000
feet
and
abstract
the
problem,
you
will
see
that
the
main
challenge
is
always
to
keep
these
meetings
efficient
right
and
it's
the
eternal
question:
how
can
we
make
that
and
so
in
in
in?
In
all
this
thing,
the
the
the
kind
of
variable
that
keeps
meetings-
very
you
know,
inefficient
most
of
the
time
is
the
is
the
chatty
interaction
right.
A
So
this
chat
interaction
also
gets
very
dispersed
right.
The
more
we
chat,
even
if
we
put
the
timer,
we
will
always
end
up
talking
about
something
else
or
go
over
right,
and
so
you
know
we
take
the
focus
from
being
highly
focused
to
dispersally
focus,
and
I
think
almost
everyone
knows
this
tool
right,
and
this
is
the
tool
that
were
they
were
crucial
in
the
past
few
months
to
help
coordinating
so
slack
on
one
side:
microsoft
team,
on
the
other.
A
They
are
this
layer
sitting
in
between
as
a
moderator
as
an
orchestrator
as
a
dispatcher
for
all
these
requests.
Imagine
that
you
jump
on
slack
to
ask
something
to
somebody
right.
It's
faster
than
take
your
phone,
make
a
phone
call,
and
you
know
get
directly
to
this
person,
but
the
same
is
microsoft
timber.
A
So
this
layer
they
act
as
coordination
layer,
and
so
when
we
look
at
cto.I
to
this
problem,
we
actually
saw
that
yes,
zlat
could
act
as
one
of
this
coordinator
and
dispatcher
right,
but
people
would
act
on
this
mesh
on
this
operational
mesh.
Imagine
that,
because,
inevitably,
what
we
do
in
slack
is
to
solve
the
logistical
complexities
to
solve
business
processes.
A
When
we
ask
a
question,
we
are
actually
interacting
with
a
workflow
with
a
question
with
with
a
business
problem
with
a
technical
problem
right,
and
so
this
is
basically
where
slack
access
or
microsoft
team
that
acts
as
a
perfect
coordinator
in
this
phase.
So
we
look
at
this
problem
we
said,
but
we
all
try
to
solve
the
same
problem
over
and
over
again.
The
questions
that
we
are
asking
are
always
the
same.
Mostly
the
answers
might
differ,
but
what
doesn't
differ
are
the
processes
to
solve
right
and
the
more
we
evolve.
A
This
interaction,
the
more
this
process.
They
lean
out
the
simplified
they
become
more
predictable.
So
we
look
at
this
problem.
We
said,
but
we
technology
already
brought
us
this
kind
of
concept
right
of
of
micro.
Why
don't?
We
take
a
very
complicated
process,
a
process
that
takes
a
lot
of
iteration
to
be
built
and
completed
a
transaction
right,
a
business
transaction
inside
of
your
organization
and
simplified
at
the
bare
minimum.
Like
docker?
A
Did
we
exactly
put
in
a
box
like
a
micro
service
and
we
make
it
reusable
like
a
micro
frontend,
we
make
it
easy
to
extend.
While
we
keep
the
same
experience,
we
we
sit
on
top
of
slack
and
the
command
line,
I'm
a
command
line.
Guy
I
use
vim.
I
use
my
terminal
the
whole
time
I
live
inside
of
the
terminal,
and
so
that's
my
way
to
interact
right,
but
that
that
doesn't
differ
in
order
to
equalize
access
the
access
and
the
interactions
we
need
to
give.
A
We
need
to
provide
multiple
channels
like,
for
example,
slack
micro,
microsoft
teams
and
the
most
important
thing
is
in
order
to
learn
and
to
improve
this
process
and
make
this
process
better
and
better
and
better
and
better
again,
we
need
to
collect
data
right.
So
if
we
take
a
step
back
and
look
at
the
picture,
we
see
that
basically,
this
problem
can
be
solved,
layering
different,
different
tiers
or
overlay
networks
right.
I'm
I'm
now
hinting
to
a
service
mesh
right.
That's
why
we
call
it
the
ops
mesh,
but
you
know
I'm
italian.
A
I
love
cooking.
I
love
food
and,
if
you
check
any
of
my
talks,
I
always
talk
about
food,
and
this
time
is
no
exception
for
you
all
right.
Let's
cook
this
recipe,
we
just
got
the
base
right
in
italian.
We
call
it
the
sofrito
right
when
you
have
onion
celery
and
carrots
as
a
base
almost
for
everything.
A
I'm
I
left
out
our
best
friend
kuma
for
a
second
just
because
I
just
want
really
to
focus
on
this
particular
piece,
but
truth
is
to
be
told.
We
leverage
kuma
largely,
and
I
leverage
kuma
largely
in
all
my
solution,
because
I
think
it's
the
most
elegant
is
the
ultimate
service
mesh.
I
can
tell
you
I
tried
many.
None
is
as
good
as
kuma.
A
If
you
haven't
done
it
yet
check
it
out,
but
let's
go
back
to
kong
and
insomnia
right.
We
came
with
this
idea.
We
conceptually
said
building
apis.
There
is
a
continuously
repetable
process.
The
whole
process
of
governance
is
just
a
repetition.
It's
a
workflow,
and
you
know
I
travel
a
lot.
I
told
you,
I
did
a
lot
of
consultancy
and
so
for
me
was
very
simple
to
resemble
with
it
with
a
concept
of
a
concert
you
go
to
an
hotel.
You
discover
a
new
place.
A
A
Because
we
are
able
to
create
workflows
that
can
be
equally
distributed
and
that's
what
humans
usually
did
in
meetings.
That's
what
processes?
They
did
that's
what
many
companies
they
ended
up,
building
over
and
over
and
over
again,
and
so
everything
starts
with
generating
an
encapsulated
application
right.
So
if
you
go
and
download
the
ctow
cli,
you
will
see
that
you
can
basically
take
an
op
and
a
knob
can
run
and
you
can
generate
your
application,
but
you
can
do
it
with
with
anything
right.
It's
not!
A
I'm
not
here
to
sell
you
cto
that
yeah
I'm
just
using
it,
because
it's
the
most
familiar
thing
that
I'm
playing
with
right
now,
but
you
can
literally
build
it
with
anything.
You
can
write
your
own
bash
script
and
template
your
application.
But
what
I'm
saying
is
that
think
about
your
service
as
an
encapsulated
deterministic
repeatable
unit
right,
because
that's
what
microservices
are
and
now
what
we
do?
We
inject
an
api
manifest
file
which
eventually
will
transpire
in
a
declarative
configuration,
and
I
think
you
are
all
starting
to
win
where
I'm
going.
A
But
let's
start
to
look
into
this
right
and
encapsulation
allows
for
determinism
right.
The
most
complicated
thing
is
to
create
determinism
in
a
distributed
system
and
encapsulation
allows
us
to
create
this
unit
this
this,
this
basically
magic
ball
where
we
put
our
service
and
we're
able
to
repeat
it
everywhere,
right,
like
docker,
did
abstracted
that
encapsulation
problem
that
virtualization
problem.
A
So
let's
look
at
the
solution
a
little
bit
as
a
as
a
flow
right.
So
you
generate
your
app.
There
is
a
manifest
inside.
Clearly,
you
go
through
a
wizard
where
you
say,
for
example,
and
we
will
see
later
on,
there
are
some
business
questions
right
so
wants
this
api.
What
is
api
doing
when
is
when
is
a
plan
to
be
released?
When
is
the
plan
to
be
retired
right?
What
is
the
the
the
current
version
right?
A
What
are
the
dependencies
all
those
kind
of
business
information
together
with
the
pure
and
simple
networking
right,
because
we're
building
an
api
somebody
needs
to
consume
it
right.
It's
a
grpc
and
you
can
use
it
with
this
protobuf
declaration
r
is
a
rasta
or
a
graphql,
and
we
push
everything
in
together,
because
git
is
our
source
of
truth
right
and
that's
where
insomnia
comes
into
place
and
brings
that
kind
of
editor.
A
A
So
the
the
our
layer
allows
to
basically
expose
functionalities
through
commands,
pipelines,
workflows
and
exposure
through
different
multi-channel
can
be
arrested,
can
be
a
pipeline
of
a
pipeline
can
be,
but
it
can
be
as
lag
command
and
that's
where
I
want
to
focus
right,
so
I
mean
slack
and
I'm
basically
saying
hey.
I
have
a
new
api.
You
can
find
the
api
there
deploy.
It
register
that
right,
because
that's
the
most
important
thing
and
we
all
know
right-
we
use
dac
that
is
brilliant-
that
solve
this.
A
A
So,
let's
look
at
the
journey
of
registering
an
api
right.
So
what
happened
is
that
you
go
in
your
kang
api
concert.
You
type
ops
register
api
and
your
journey
starts
right.
Let's
look
at
what
kind
of
api.
Oh
is
a
rest
api.
Let's
start
to
look
into
the
team
that
is
owning
this
api.
Let's
call
them
api
pirates
right
and
let's
connect
it
with
a
github
repository,
and
in
this
case
we
call
this
fictional
company,
duffy
enterprises
and
the
the
name
of
the
the
api
is
going
to
be
party
management.
Api
right.
A
The
manifest
contains
all
this
information.
That's
why
link
it
with
git
will
allow
the
system
to
retrieve
the
information
and
propagates
them
everywhere
right.
So
there
is
a
pipeline
behind
the
scene
and
let's
apply
a
policy
right.
I
told
you,
I
would
not
mention
kuma,
but
I'm
hinting
there
right,
so
these
policies
are
actually
setting
different
policies
in
kong,
they're,
making
it
public
or
private
or
partner
only
which
applies
basically
restriction
on
api
keys,
authentication
and
especially
networking
access
through
you
know,
network
provisioning,
but
the
most
important
thing
is
that
bum
is
public.
A
Let's
move
on
the
the
concert
needs
to
start
registering
the
pipeline
runs
and
that's.
It
is
register
right.
This
is
the
epi
scenario
right
and
in
the
app
scenario
we
want
to
create
a
space
for
people
to
connect,
and
so
we
create
a
channel,
a
slack
channel,
that
we
call
api
pirates
and
we
can
link
it
to
the
api
that
we
just
deployed
so
that
you
know
where
to
go
to
connect
with
the
people
that
build
the
api
that
are
consuming
that
api.
A
So
we
create
a
community
inside
of
the
organization
through
this
process
and
that's
it
so
we
move
on
we
we
we
what.
But
what
is
sorry
what
if
the
api
already
exists
right
and
if
the
api
already
exists.
What
happened
is
that
we
are
identifying
the
the
the
overlapping
parts
right,
and
so
we
are
actually
suggesting
you
not
to
build
something
new,
but
to
just
connect
with
the
people
and
that's
it
and
that's
when
you
enter
the
channel.
You
enter
that
conversation
and
it's
historical.
It's
there.
A
We
can
reconcile
them,
but
we
spoke
about
discoverability
right
and
what
about
searching
an
api
searching?
An
api
is
the
same
process.
It
goes
through
selecting
the
type
of
search
that
we
want
to
do.
Imagine
that
you
want
to
search
for
a
model
right,
and
so
we
are
selecting
party
management,
and
you
know
the
conservation
is
going
to
search
for
it
and
bomb
behind
the
scene.
Our
platform
is
going
to
coordinate
this.
It's
going
to
go
into
our
registry,
retrieval
information,
but
especially
it's
going
to
act
as
a
dispatcher.
A
It's
like
an
uber
for
your
apis.
It's
going
to
take
you
from
a
to
b
in
the
most
efficient
and
effective
way,
and
that's
it
and
that's
when
you
connect
again
with
people,
because,
let's
not
forget
behind
these
apis,
that
are
real
people
right
and
we
don't
want
to
forget
about
that.
And
you
know
there
are
different
kind
of
type
of
search
that
you
can
do
also
by
business
domain.
Imagine
that
you
are
searching
for
a
specific
description
right.
A
I
said
in
the
manifest
there
is
also
a
business
description,
for
example,
api
to
provide
the
customer
information
right,
and
so
you
search
for
individual
full
name,
and
then
you
know
it
connects
with
the
api
that
can
provide
this
business
description.
One
or
many
because
you
know
there
might
be
multiple
apis
and
that's
the
moment
when
you
start
to
go
deeper
and
discover
clearly
the
order
is
based
on
similarity
and
match
with
your
search
parameters,
and
but
sometimes
you
just
need
that
property
right.
A
You
have
that,
for
example,
in
this
case,
when
we
go
for
property,
we're
going
to
look
for
individual
dot,
full
name
is
connecting
you
with
the
services
that
have
that
property
right.
So
we
want
to
remove
the
friction
between
you
and
your
acceleration
and
acceleration
of
your
team
and
acceleration
to
business
and
to
market,
and
the
most
important
thing
is
that
we
never
forget
about
connecting
you
where
to
find
the
api,
but
especially
how
to
connect
with
the
people
that
build
this
api.
A
And
if
you
look
at
the
holistic
picture-
and
I
would
love
actually
to
take
a
couple
of
minutes
here-
is
that,
like
I
told
you,
the
search
happens,
because
we
have
this
declarative
format
right
we
having
encapsulated
code,
so
we
can
deterministically
kind
of
traverse
the
the
the
the
configuration
of
that
particular
application.
We
have
the
con
declarative
configuration
that
is
structural
right.
It
basically
gives
routes,
policies
and
those
kind
of
things,
and
then
there's
the
api
manifest
that
describe
actually
how
this
this
api
fits
in
the
enterprise
or
the
public
ecosystem.
A
It
goes
through
a
pipeline
and,
as
you
can
see,
basically
gets
propagated
into
an
internal
catalog
but
especially
gets
injected
into
kong
right
kong.
Like
I
said
there
is
a
cyto
car,
and
now
you
will.
We
will
discover
why
all
this
pipeline
pushes
data
into
a
elastic
search,
because
we
want
to
be
fast.
A
You
know,
augmented
by
all
these
kind
of
functional
layers,
on
top,
so
thanks
again
to
comfortability
this
phenomenal
product
right
and
kuma
to
extend
the
concept
of
distribution
to
the
next
level,
but
I
want
actually
to
invite
everyone
to
join
our
community
where
we
can
continue
this
conversation,
this
one
it
was
just
a
teaser
I
wanted
to
tease.
I
wanted
to
give
you
that
appetizer
to
continue
that
conversation,
because
we
really
believe
that
this
is
one
of
the
use
cases
that
we
are
going
to
open
source.
A
We
are
going
to
make
it
open
and
available
to
you
guys
to
everyone,
so
please
also
keep
an
eye
on
our
github,
because
we
are
going
to
soon
release
most
likely.
This,
so
old
package
is
going
to
be
released
as
an
op
in
before
the
end
of
the
year.
We
are
working
to
finalize
and
putting
together
pieces,
so
you
will
be
able
to
to
have
your
own
personalized
concerns
right,
and
so,
as
every
italian.