►
From YouTube: API Platform Conference 2022 - Fran Mendez - Building schema-first event-driven archi with AsyncAPI
Description
In this talk, Fran will show you how to build schema-first APIs and event-driven architectures using the AsyncAPI specification and Glee.
At the end of the talk, you should have a clear understanding of the benefits of schema-first development and how it can make your code more resilient and maintainable.
_________
More info: https://api-platform.com/con/2022/
Twitter: https://twitter.com/ApiPlatform
Music credits: Vanilla by Time Warp
A
Thanks
for
having
me
thanks
for
you
know
to
let
tgil
I
hope,
I'm
pronouncing
it
correctly:
Kevin
Cecile
and
team
I'm.
Sorry
I,
don't
have
a
really
good
introduction,
like
Lucas
just
did
with
the
champagne,
so
I'll
just
drink
water,
but
yeah
I
hope
it
will
be
enough.
I,
don't
think
you
can
see
anything
right
there.
B
C
A
A
A
Let
me
grab
this
also
mentioned
that
this
is
my
first
in-person
talk
after
two
years,
so
it
feels
really
weird
now
what
is
what
is
my
chair
where's,
my
my
screen
right?
So
sorry,
so
you
know,
my
name
is
Fred
Mendez
and
I
work
as
a
director
executive
director.
This
is
really
ugly
name
for
the
async
API
initiative.
I
also
work
as
a
director
of
engineering
at
Postman
and
but
basically,
what
I
do
is
I
I
do
async,
kpi
full-time
and
how
many
of
you
know
about
this
in
kpi?
A
A
A
Yeah,
so
let
me
speak
a
little
bit
about
the
specification.
What's
the
purpose
of
it
right,
so
many
people
are
used
to
use
Swagger
open,
API
I
know
many
people
will
kill
me
for
Q
for
keeping
saying
Swagger
but
yeah
open
API
for
rest.
Apis
I'm
sure
that
you
used
to
you
to
use
as
well.
Graphql
schema
language.
A
So
from
the
graphql
you
know
all
the
ecosystems
you
have
the
schema
language
as
well,
and
and
that's
a
specification
right,
so
those
are
for
different
kinds
of
apis
so
for
even
architectures,
or
for
even
driven
microservices
or
Internet
of
Things
apis
or
streaming
apis.
Any
kind
of
streaming,
API
like
and
actually
like
any
kind
of
system
that
is
based
on
the
exchange
of
messages,
can
be
defined
with
with
the
same
kpi.
A
A
Async
API
is
not
bound
to
any
specific
protocol.
Why?
Because
there
are
many
protocols,
there
are
many
and
it's
impossible
that
we
choose
one
of
them
like.
If
we
go
with
Kafka,
then
what
about
mqtt
and
what
about
the
websockets?
And
what
about
amqp
right?
That's
or
if
we
choose
amqp?
What
about
the
rest
right?
So
that
doesn't
mean
that
the
information
about
the
protocol
in
the
spec
is
not
important.
We
care
we
care
about
the
I
mean.
A
A
If
you're
used
to
open
API
I'm
sure
that
this
structure
looks
familiar
to
you,
it
starts
with
an
async
API
field
like
in
open
API.
Then
it
follows
channels
which
is
similar
to
pads
in
open
API.
Somehow
and
then
you
can
have
like
a
list
of
channels
and
there
you
can
describe
what
your
application,
what
what
the,
what
the
clients
or
the
consumers
of
your
API,
can
publish
or
subscribe
right,
so
powerless,
2
or
subscribe
to
right.
So
there
you
can
Define
what
kind
of
message.
A
So,
for
instance,
let
me
put
it
this
way:
I
just
I,
I'm
running
a
product
myself
and
I
want
to
build
an
API
that
an
even
driven
API
that
whenever
I
receive
a
a
sign
up,
I
get
a
new
user
signing
up
in
my
product,
I
want
to
send
a
message
to
a
broker
to
a
message
broker
like
Kafka
like
rabbit
and
Q
like
mosquito
whatever,
and
so
others.
Other
components
of
my
architecture
can
get
a
notification
that
this
actually
happened
and
they
can
react
and
do
something
accordingly
right.
A
So
there's
a
message:
there's
a
message
that
I
I
need
to
send
to
the
to
the
broker,
and
there
is
a
channel
and
a
channel.
It's
usually
called
a
topic,
a
routing
key,
the
event
name
as
well.
Sometimes,
even
though
I
find
it
weird,
but
it's
also
it's
also.
You
can
also
find
it
there
and
then
there
is
a
structure
for
your
message,
so
this
structure
of
your
message
can
be
defined
just
like
in
open
API.
A
We
use
Json
schema
internally
right,
so
you
can
use
Json
schema
to
Define
your
message
structure
so,
but
this
talk
is
not
about
async
API.
The
specification
I
really
encouraged
you
to
to
look
about
a
little
bit
about
the
the
spec,
because
I
think
it's
a
it's
a
really
interesting
work
that
has
been
happening
for
the
last
five
years
already
so
so
yeah
have
a
look.
The
thing
is
that
this
talk
is
about
schema
first
types
of
apis.
How
many
of
you
know
what
schema
first
means
in
in
this
context,.
A
Only
one
in
the
whole
room,
I'm
amazed,
that's
really
cool,
so
well.
I
I
hope
that
many
of
you
already
I
think
I
asked
before
that
you
were.
You
were
used
to
graphql,
you
know
what
graphql
is
and
what
the
graphql
schema
is
right.
Just
to
make
sure
you
know
what
graphql
is
and
the
graphql
schema
language
is
not
many.
Okay,
so
thing
is
that
when
we
develop
an
a,
for
instance,
a
rest
API
and
we
Define
it
with
open
API
the
implementation
and
the
and
the
open
API
definition
are
usually
decoupled
or
separated
right.
A
So
there
is
the
risk
that
I
create
a
new
endpoint
or
change
something
on
my
API
and
I
forget
to
put
it
on
the
open,
a
paid
document
or
there's
also
the
risk
that
I
put
it
in
my
open
API
document,
but
I'm,
but
I
make
a
mistake.
That
also
can
happen
or
can
also
happen.
The
other
way
around
I
add
something
to
my
open
API
document,
but
I
implement
it
incorrectly
or
I
forget
to
Simply
implement
it,
which
is
a
weird
case,
but
it
could
happen
as
well
right,
so
they
are
both
decoupled.
A
So
what
happens
here
is
that
over
time,
teams
tend
to
develop
their
apis
and
they
have
strict
deadlines
right
like
they
they
rush,
they
have
to
ship
code
faster
and-
and
you
know,
updating,
open,
API
or
async
API.
It's
a
pain
in
the
ass.
To
be
honest,
so
it's
like
it's
a
stone
in
in
the
way
right
and
it's
not
required
for
the
product
to
work.
You
can
just
ship
your
product
without
open,
API
racing
kpi,
so
that
is,
that
is
a
problem,
because
then
you
end
up
having
documentation.
A
That
is
not
strictly
telling
the
truth
and
the
rest
of
the
teams
are
thinking
that
this
is
a
real
truth
and
that's
a
problem.
And
then
things
are,
you
know
creating
more
internal
tickets
or
or
external
tickets.
Saying
like
hey,
your
API
says
that
I
can
do
this,
but
it's
not
really
true.
That's
a
problem
right.
A
So
in
the
end,
what
happens
over
time-
and
it
happened
to
me
in
many
companies-
is
they
drop
the
open,
API
file
or
they
drop
the
async
pay
file?
You
know,
and
it's
a
problem
right,
you
need,
you
really
need
someone
who's
really
interested
in
maintaining
this
documentation
or
a
team
right
to
take
care
of
it.
So
so
is
there
like.
The
question
here
is:
is
there
a
way
to
make
the
two,
the
implementation
and
the
definition
more
tied
together?
A
So
is
there
a
way
that
we
can
make
it
just
so
if
we
make
a
mistake
on
the
open,
API
document
or
this,
it
can
be
a
document
in
this
case
it
gives
us,
you
know
a
warning
or
something
like
that
or
an
error
like
saying.
No,
you
can
do
this
because
the
implementation
is
doing
something
different
and
then
that's
the
that's
the
question
that
we
we
get
asked
but
I
think
yeah.
A
A
So
in
the
case
of
graphql
or
grpc,
you
have
a
document
that
defines
all
your
queries
and
mutations
of
your
graphql
API
and
that's
called
the
graphql
schema
right
and
then
once
you
have
that
defined,
you
bind
your
code
to
your
graphql
schema.
So
what
happens?
Is
that
because
it's
strictly
typed,
if
you
commit
a
mistake
in
the
code
and
return
something
different
or
pass
something
different
to
your
API?
A
It's
gonna!
It's
not
gonna
work.
It's
gonna,
give
you
an
error
right.
So
can
we
do
the
same
with
event
driven
architectures
with
async
API?
Well,
I,
guess
you
know
the
answer
right.
So
the
answer
is
yes,
so
cool
thing
about
the
cool
thing
about
you
know.
Let
me
just
highlight
this
first
doesn't
want
to
go
back.
Okay,
not
too
not
too
much.
D
A
So
then,
aside
the
front
of
the
of
the
things
that
I
just
mentioned,
there's
also
you
know
like
if
we
can
make
it
work
like
this,
that
we
Define
things.
We
use
the
async
API
file
as
a
configuration
file
right,
which
is
what
it
is
in
the
end
right.
If
we
tie
them
together,
then
what
happens
is
that
our
code
will
have
less
boilerplate.
A
This
can
be
hugely
avoided,
because
all
this
information
is
on
this
in
keypad
file.
So
why
would
you
need
to
do
all
this
ceremony
like?
Let's
use
this
in
keep
a
file
to
do
this,
for
us
right
or
to
Define?
This
sentence
for
us
and
and
yeah
and
since
we're
using
Json
schema
all
the
data
is
strictly
typed
and
validated
right.
So
perfect,
we
have
all
the
pieces
now.
The
only
thing
we
need
is
is
a
framework
that
could
do
this.
For
us
right,
that's
the
is
the
only
thing
that
we
need.
A
A
B
B
A
Look
as
a
demo
I,
usually
in
the
workshops,
what
we,
what
we
teach
is
that
let's
build
a
really
stupid
and
basic
social
network
right
for
the
sake
of
testing
this
framework
and-
and
it's
also
in
the
examples
on
GitHub
on
the
on
the
Glee
repo
on
async
API
right.
So
so
this
is
a
result
of
the
demo
right.
What
you're
seeing
as
a
result.
So
we
have
like
a
kind
of
weird
Twitter
combined
with
Instagram
or
something
like
that.
A
B
A
And
I
have
the
profile
of
ukesh
here,
let's
that
is
not
supposed
to
be
on
the
same
computer
right,
so
Lucas
is
seen
his
his
profile
or
the
the
social
network.
From
his
point
of
view
and
I'm
saying
it
from
my
point
of
view
right
so
so
what
I
want
to
teach
here
is
that
what
I
want
to
show
here
is
that
say,
for
instance,
you
see
that
this
first
publication
has
zero
likes.
A
D
A
A
The
notification
service
is
going
to
receive
this
message,
and
it's
gonna
know
that
someone
has
clicked
like
on
one
of
the
Publications
and
what
it's
going
to
do
is
it's
going
to
send
a
message
to
slack
saying:
hey,
for
instance,
hey
Lucas
friend
liked
your
publication,
your
post,
something
like
that.
Pretty
simple!
Everyone
follows
okay,
so
it
seems
pretty
simple
for
the
sake
of
the
demo
I'm
not
sending
to
slack,
because
I
will
have
to
be
configuring
things
here
and
that's
already
a
mess
as
it
is
so
so
yeah.
Let's
keep
it
simple.
A
Let
me
show
you
what
what
I'm
doing
here?
What
I
have
here
is
just
so
you
can
see
the
inners
of
the
demo
right
so
I'm,
not
even
using
a
database.
This
is
a
Json
file
that
I'm
using
as
a
database
just
to
keep
it
simple
right.
So
I
have
the
likes
here.
The
idea
of
the
post
that
has
been
liked
and
the
user
who
clicked
liked
right
and
then
I
have
a
bunch
of
users
here.
A
A
So
that's
the
that's
the
database
so
what's
happening
here
right
now.
Let's
have
a
look
at
the
well.
Let
me
also
mention
before
I
have
a
front-end
project
which
is
done
with
nextgis,
but
I.
Guess
it's
not
related
to
this
demo.
So,
let's
keep
it
out
of
the
demo
right,
and
that
is
all
it
is
all
this
interface
that
you
see
in
there,
but
I
would
love
to
have
a
look
first,
At
This,
websocket
Server,
so.
A
So
yeah
there
are
a
bunch
of
of
files
here.
How
many
of
you
are
actually
familiar
with
node.js
or
familiar
enough?
Let's
list:
okay,
okay,
so
I'm
using
typescript,
so
Glee
This
the
framework
that
we
build
to
create
this
schema
first
apis
is
using
typescript.
So
if
you
we're
gonna
go
down
from
the
bottom
app
from
the
bottom,
so
we
have
the
typescript
configuration
readme
packet,
Json
package,
log
Json
license.
A
A
A
So
I
try
to
keep
it
simple
as
simple
as
possible,
because
this
is
a
presentation
and
I
know
you
don't
want
to
be
reading
code
on
a
screen
during
the
presentation
right
but
yeah.
Let's
try
to
keep
it
as
simple
as
possible.
What's
happening
is
there
is
a
function?
The
name
of
the
function
is
the
name
of
the
file
unlike
dislike
I.
A
Think
it
should
be
unlike,
unlike
I,
should
be
correcting
this
English,
but
yeah,
so
that
that
is
that
function
is
executed
every
time
someone
hits
the
like
button,
either
to
like
something
or
to
unlike
something
that
sounds
weird
and
and
yeah,
and
we
get
the
event.
So
the
event
is
the
information
that
we're
sending,
which
information
are
we
sending
to
the
whatever
information
that
we're
sending
to
the
web?
A
Socket
thanks
to
the
websocket
server,
we'll
get
it
here,
so
we're
gonna
collect
all
the
events
that
we
want
to
send
to
the
as
a
response
to
this,
but
first
of
all,
we're
gonna
do
something
which
is
if
the
event
that
is
happening
is
is
a
like
event.
Like
someone
is
liking,
a
post,
we're
gonna,
save
it
to
the
database
right
and
we're
gonna
send
something
as
a
as
a
result,
which
is
we're.
A
Gonna
send
this
this
event
here
this
payload
here
the
the
idea
of
the
post
and
the
ID
of
the
user
to
the
post
liked,
Channel
or
topic
to
the
mosquito
server
to
the
mosquito
broker,
which
is
this
one
here,
so
we're
gonna
this.
It
is
describing
this
connection
we're
sending
this
this
message
to
the
mqtt
broker.
A
At
this
post
right,
I
want
to
communicate
everyone
that
the
count
of
likes
have
been
has
been
updated
and
the
idea
of
the
post
that
has
been
updated
is
this
one
and
now
the
total
count
is
this
one
right.
This
is
just
so
I
can
refresh
the
UI
on
both
windows.
At
the
same
time,
right
you
see
that
you
saw
that
it
was
communicating
I
clicked
in
one
and
then
the
other
one
was
reacting
right.
So
yeah
I
think
it's
pretty
simple
logic
here
right
and
then
we
just
return.
A
This
special
Glee
object
right,
which
says
that
I
want
you
to
send
all
these
events.
Look
at
this
logic.
I'm
handling
web
circuits
I'm
handling
mqtt
connections
to
mosquito.
But
where
is
the
code?
What
is
the
code
to
to
actually
spin
up
a
websocket
server?
What
is
the
code
for
mqtt
connection
for
the
for
connecting
to
the
to
the
client
and
everything
so
there?
It's
not
there
and
I
promise
like
I.
Just
hide
I
I
I
said
that
I
was
going
to
show
you
this.
A
This
live
file
is
just
functions,
a
bunch
of
functions
in
logic.
Just
so
I
could
keep
this
file
here
as
simple
as
possible
for
demo
right,
but
but
there
is
no,
there
is
no
logic.
There
is
no
code
connecting
to
any
any
kind
of
broker
or
or
spinning
up
server
right.
Everything
is
described
here.
So
we
have
this
file
saying
this
is
our
social
network.
We
have
two
servers
websockets
and
a
mosquito
with
all
the
details.
A
A
A
There
is
described
here
below
not
really
interesting
for
the
demo,
like
it's
a
bunch
of
data
that
you
need
to
pass
right
and
it
says
that
it's
only
for
the
mosquito
server
right,
so
I
think
everyone
is
is
aligned
here.
If
someone
is
really
not
like
aligned
with
what
I'm
saying
or
like
it's
not
following,
please
make
a
weird
sound
somewhere
and,
and
just
so
I
can
I
can
notice
it
and
explain
it
again.
So
so
yeah
I
was
saying
that.
A
So
this
is
the
websocket
server,
but
the
notification
service
service
is
exactly
the
same
right,
but
when,
when
it
receives
the
event,
it's
just
going
to
send
a
notification
to
Slack
I
hide
all
the
logic
for
the
demo
purpose.
But
if
we
go
to
the
leave,
folder
you'll
see
that
there
is
a
bunch
of
logic
that
I
actually
commented
this
morning
right.
A
So
so
so
we
can
keep
it
simple.
In
case
you,
like
your
own
blog
post,
you
get
a
a
really
cool
message.
I
will
show
you
and
then
in
case
you,
like
other
other
people,
blog
posts
or
post
right.
You
get
to
send
a
notification
to
somewhere
right
to
slack
in
this
case.
So
it's
the
same
thing
and
it
has
its
own
async
API
file
for
the
notification
service.
It's
only
connecting
to
Mosquito.
A
You
can
publish
it's
a
common
misconception,
so
this
notification
service
is
subscribing
to
post
liked,
right
and
and
yeah,
and
we're
just
saying
that
in
the
in
the
very
moment
we
receive
a
message
here
in
this
in
this
in
this
topic
in
this
channel,
we're
going
to
execute
the
own
post
liked
function,
which
is
here
right
this
one
to
send
a
notification
cool.
So
we
almost
got
it
everything.
A
A
And
then
it
says
information
was
broadcasted
to
this
last
through
this
last
channel.
Right
passing
this
information,
which
is
post,
ID,
total
count,
zero
likes
and
the
type
of
the
event
is
likes,
count
updated
notice
that
we
have
the
type
there,
because
we
can
only
have
one
channel
on
on
websocket
so
yeah.
So
that
is
what
we
that
is
what
we
get
so
because
this
event
was
broadcasted
to
all
the
clients.
A
Then
Lucas
also
got
it
and
that's
why
it's
updating
to
zero
right.
So
that
is
this
part.
But
let's
move
to
the
notifications
service
right,
I'm,
doing
a
small
spoiler
there,
all
right!
So
if
I
click
on
my
own
post
right
and
I,
like
my
own
post.
Oh
no,
sorry!
This
was
Lucas
I'm
using
Lucas
profile.
So
if
I
click
on
my
own
post
here,
what
I
get
is
it's
great
that
you,
like
yourself
but
I'm
not
going
to
send
a
notification?
A
Send
a
message
to
slack
hey-
and
this
is
my
slack
ID
Lucas
garnishki
liked
your
post.
You
can
see
it
here
right.
Obviously,
the
URL
is
not
available
to
internet,
but
but
it
could
be
right
so
yeah.
So
that's
pretty
much
the
the
demo,
let's
just
moved,
because
we're
running
out
of
time.
So,
let's
just
move
forward
so
yeah
I
want
you
to
to
just
think
up
about
for
a
moment
about
what
just
happened
here.
A
I
just
defined
all
the
communication
in
async
Pay
files
for
each
of
the
services
like
what's
going
to
be
sent
and
what's
going
to
be
received,
what's
the
shape
of
the
messages
and
so
on,
what
kind
of
protocol
are
we
going
to
use?
Where
are
the
servers
or
the
brokers,
all
this
kind
of
of
information
right
with
this
file?
We
can
easily
generate
documentation
quickly,
right,
like
with
open
API,
but
not
just
that.
A
We
have
now
the
Glee
framework
that
will
read
this
information
and
the
only
thing
that
it's
asking
you
is
to
provide
your
business
logic
like
what
should
I
do
when
I
receive
this
message.
If
I
receive
a
message
on
this
channel,
just
give
give
me
this
function
like
what
should
I?
Do
you
write
the
function
right?
Obviously,
we
cannot
write
the
function
for
you,
so
so
it
is
like
it's
custom
logic.
It's
custom,
business
logic
right.
So
what
happens
is
over
time.
A
There
are
by
the
way,
I
didn't
show
it,
but
there
are
also
mechanisms
to
send
event,
because,
right
now
what
I
saw
is
like
when
you
receive
an
event,
you
can
respond
right.
You
can
react
and
send
other
events,
but
you
may
be
the
first.
You
may
want
to
be
the
first
one
to
send
the
event
and
instead
of
reacting
to
an
incoming
one
right,
there
are
also
mechanisms
on
the
on
Glee
that
lets
you
send
an
event
on
specific
system
events
and
application,
lifecycle
events.
A
So
what
happened
here
is
that
there
there
is
no
boilerplate
code.
I
just
have
a
business
business
logic
there
like
what
should
I
do,
should
I
send
a
notification
to
slack
so
like
store
it
on
my
database.
What
should
I
do
right
so
over
time?
What
happens
is
this
code
is
going
to
keep
evolving
and,
if
you
don't
add
it
to
the
Sync
API
file,
it's
not
going
to
work
and
actually
I
promise
that
it's
not
well
I,
don't
have
I,
don't
really
have
time
so.
A
But
I
wanted
to
show
you
that
if
I
change,
the
the
I
think
definition
and
whenever
there
should
be
a
number
I
put
it
that
this
will
be
a
Boolean
or
string
or
something
ugly
will
fail
and
we'll
show
you
the
error
that
you're
not
sending
the
right
information
either
incoming
or
outgoing
it
will
validate
for
both.
So
you
get
validation
out
of
the
box
as
well.
Plus
documentation
will
be
always
updated
right.
So.
A
So
yeah
now
a
little
bit
about
the
initiative
like
really
quickly
quickly.
Last
year
we
joined
the
Linux
foundation
so
we're
now
a
Linux
Foundation
project
I
like
for
the
for
the
sake
of
transparency.
We
aim
always
to
share
everything.
We
do
in
public
everything
right
and
we
keep
always
all
the
data
in
public,
including
the
money.
So
this
is
the
money
that
we
have
right
now
in
the
foundation.
You
can
see
it
on
our
open,
Collective
profile
right
and
you
can
see
where
we
spend
it.
A
You
can
obviously
donate
as
well,
but
we're
not
with
this
amount
of
money,
we're
not
going
to
ask
you
to
donate
because
I
think
we're
doing
right.
So
we're
fine
for
now
and
let's
let
company
donate
so
so
yeah.
That
is
the
money
stuff
that
we
have
right
now
and
what
do
we
do
with
this
money?
Because
we
can
keep
the
money
there
forever
right.
We
spend
the
money
in
the
in
the
community
right.
We
try
to
make
it
as
Community
Driven
as
possible.
A
Sorry,
oh
yeah.
Okay,
no,
no
problem,
no
problem.
Take
a
picture
so
yeah
big
shout
out
to
our
our
sponsors
and
it's
okay.
Now,
yeah
no
worries,
so
you
can
you
probably
notice
that
there
are
bigger
logos
on
top
Postman
and
Solas,
so
these
are
the
companies
who
are
dedicating
not
only
money
but
people
working
full-time
on
on
async
apis.
So,
in
my
case,
my
team
at
Postman,
we
are
already
12
people
working
full-time
racing
kpi,
so
so
yeah
and
in
the
case
of
Solas
I,
think
it's
already
too
so
yeah.
A
Does
it
mean
that
we
want
to
compete
with
open,
API,
graphql
and
so
on?
No,
we
want
to
integrate
with
them.
So
if
you
have
open
API,
if
you
have
graphql
and
other
formats,
you
can
use
it
on
async
API
and
it
will
work
with
async,
API,
tooling
and
last
but
not
least,
November
we're
celebrating
our
second
actually.
Third
I.
Think
kpi
conference
and
I
encourage
you
to
join.
It's
going
to
be
virtual
Indian,
not
not
in
person,
so
yeah
I
think
that's
it.