►
Description
This talk was part of AsyncAPI Online Conference:
- AsyncAPI Initiative website - https://www.asyncapi.com/
- You can also watch this talk as part of full conference recording with audience questions in the LiveChat - https://youtu.be/oMSzGc5bDr4?t=16209
TALK ABSTRACT
A long standing gap has been filled! The AsyncAPI specification has risen as the industry standard for defining asynchronous APIs and is being incorporated into several products to enable a better tomorrow for Event-Driven Architecture (EDA). In this talk you will learn how AsyncAPI has been adopted by the Solace PubSub+ Event Portal to provide full lifecycle management of your EDA. I will focus on how you can use the tool to design your architecture and demonstrate how to use the AsyncAPI’s Code Generators to quickly develop a Spring Cloud Stream microservice.
SLIDES
https://www.slideshare.net/solacedotcom/asyncapi-conference-from-design-to-code-with-marc-dipasquale
A
A
A
So,
first
to
start
off,
I
think
some
of
you
may
have
seen
this
chart
before,
but
studies
have
definitely
shown
that
data
is
more
valuable.
The
sooner
you
use
it
with
it
being
most
valuable.
You
know
in
real
time
within
seconds
of
a
change
in
state
occurring.
So,
historically,
what
we've
seen
is
a
lot
of
batch
ETL,
where
you
appear
periodically
get
a
bunch
of
state
changes
at
once
on.
You
extract,
transform
and
load
them
into
some
sort
of
data
store
and
then
do
historical
analysis
on
that
data.
A
So
that's
has
the
least
that's
getting
the
least
value
out
of
your
data.
You
can,
of
course,
get
more
value
out
of
your
data
by
following
what
I
would
call
a
store
and
query
approach.
So
in
this
approach,
as
events
occur,
you
would
actually
take
them
process
them
and
store
them
in
a
data
store
and
then
you'll
have
applications
that
will
query
on
the
data
when
they
need
it.
So
in
many
cases
a
REST
API
is
used
for
this,
but
to
get
the
most
value
out
of
your
data,
you
really
need
to
become
event-driven.
A
So
the
question
is:
if
we
want
to
be
real-time,
then
then,
why
are
we
not?
Why
are
organizations
not
taking
advantage
of
this,
and
so
the
answer
for
that
is
because
it's
it's
not
easy,
you
know,
being
event-driven
is
not
easy,
so
only
organizations
that
have
actually
had
to
become
real-time
have
been
doing
that.
So
this
diagram
is
actually
a
real
diagram
and
it's
an
example.
A
It's
a
architecture
of
the
FAA
is
national
air
space
system,
and
so
they
had
a
need
to
be
real-time
because
they
need
to
know
you
know
exactly
where
the
planes
are,
whether
they're
in
the
air
or
on
the
ground.
They
need
to
be
alerted
of
weather
phenomenons
as
they
occur.
So
they
can
make
changes
and
keep
people
safe,
and
so
many
more
use
cases
exist
throughout
this
throughout
this
domain
and
factored
into
this
architecture.
A
What
else
was
being
affected
is
quite
difficult,
so
you
know
why
is
this
the
case,
and
so
the
reason
is
there
are
a
lot
of
reasons
that
it's
hard
to
build
these
event-driven
applications
and,
and
this
really
the
who,
what
when,
where
questions
that
need
to
be
asked.
So
where
do
you
discover
what
events
are
available
for
reuse
now?
Why
does
an
event
even
exist
in
the
first
place?
What
topic
do
you
subscribe
to
receive
it?
What
changed?
A
How
do
you
determine
the
data
structure
of
the
payload
once
you
know
that
the
event
actually
exists?
Who
should
I
have
access
to
it?
So
in
many
cases
there
are
security
concerns
about
which
systems
can
access
certain
data
and
which
can't
so
you
want
to
make
sure
that
you
have
those
security
rules
enforced
in
your
operational
system
who
made
the
latest
revision.
So
if
something
broke,
how
do
you
know
who
made
the
last
change?
A
Who
can
tell
you
more
about
it
when
you're
not
sure
when
you
have
such
a
complex
architecture?
You
know
when
you're
not
sure,
if
a
certain
event
is
something
that
you
want
who's
the
owner
of
that
event.
Who
can
I
go
talk
to
you
who
can
I
check
with
to
make
sure
to
hear
about
when
the
next
version
is
coming
out?
Now?
Is
your
change
backward
compatible
if
I
make
a
change
which
systems
am
I,
might
I
break
and
again,
who
is
impacted
by
your
change
downstream
and
also
does
it
complete?
A
A
There's
a
few
solutions
that
help
with
this
so
open
api
on
the
open
api
initiative
is
an
open
source
initiative
that
provides
a
specification
to
define
your
restful
synchronous
apps.
It
also
provides
swagger
tooling
on
to
help
generate
code
from
those
specifications
from
the
documents
that
specify
an
app,
but
also
there's
all
these
other
things
that
you
still
need
to
do.
A
So
that's
why
I
open
API
management
platforms
are
available,
and
so
these
API
management
platforms
provide
an
API
portal
that
I
allow
you
to
really
document
your
applications
register
the
applications
for
governance
reasons
analyze
what's
going
on,
so
you
can
continue
to
improve
and
to
monetize
on
your
solutions.
They
also
allow
you
to
participate
with
your
community
and
collaborate,
collaborate.
You
know
across
development
teams,
developers
with
architects,
vice
versa,
to
really
design
and
implement
your
solution,
and
then,
of
course,
they
allow
for
better
productivity
by
using
tooling
such
as
swagger
to
do
cogeneration.
A
So
this
tool
set
between
open,
API
and
API
management
platforms,
really
answers
the
who?
What
when,
where?
Why
and
how
for
restful
api,
but
inventing
an
event-driven
is
just
different
and
it
the
event
is
really
the
interface
applications
are
decoupled,
so
the
challenge
is
different
and
you
can't
use
an
API
management
platform
to
solve
the
event-driven,
the
who
want
one
way
or
for
event-driven
architectures.
A
So
where
do
we
go
from
here?
Well,
as
you
probably
guess,
by
the
name
of
this
conference,
async
API
is
providing
part
of
this
solution,
so
async
API
is,
of
course,
it's
kind
of
risen
as
the
industry
standard
for
defining
your
asynchronous
API
s
and
an
event-driven
api's.
So
it
provides
not
only
a
specification,
but
it
is
also
providing
code
generators,
so
you'll
be
able
to
define
your
your
application,
as
you
can
see
on
the
screen
here.
So
on
the
right.
You
know
this
is
a
yeah
mole
representation
of
a
async
API
document.
A
Where
you
have
your
version,
you
have
information
about
your
application.
You
have
the
different
channels,
and
in
this
case
it
is
subscribing
to
and
the
schemas
that
define
the
message
that
it's
going
to
receive,
but
you
need
more
than
just
a
specification
and
code
generators
so
like
we
have
the
API
management
platform
for
the
restful
world,
we
need
an
event
platform
for
asynchronous
interactions.
A
So
to
answer
the
the
same
types
of
questions
right,
so
we
need
an
event
portal
to
document,
register,
analyze
collaborate
and
to
have
better
productivity.
So
we
have
a
sink
a
peon,
both
the
specification
and
the
code
generation
that
I
just
talked
about
to
help
with
this,
but
the
platform
itself
has
not
been
available
until
now,
and
so
solace
is,
has
introduced
its
pub/sub
plus
event
portal.
So
this
event
portal
is
really
the
equivalent
of
the
API
portal,
but
it
for
the
event-driven
world.
A
So
now,
with
the
event
portal
available,
we
can
have
a
similar
experience
as
we
have
in
the
restful
world.
So
in
the
rest
for
world.
You
know
we
have
the
API
management
tool
and
it
can
output.
You
know
it
gives
you
a
specification:
it
an
open,
API
document,
defining
your
app,
you
use
wire,
tooling,
to
do
code
generation,
you
get
generated
code
and
your
apps
communicate
usually
using
HTTP.
So
now,
with
the
pub/sub
plus
event
portal,
you
can
use
that
to
manage
your
entire
event-driven
architecture
and
then
use
async
api.
A
They
used
to
give
you
guys
specification
to
document
your
apps
and
use
async
api
code,
generators
to
generate
event-driven
code
and,
of
course,
communicate
over
a
whole
bunch
of
different
runtime
protocols,
unlike
a
m
tpem
QT
t
and
there's
other
open
standards
and
out
there
and
available,
and
so
this
is
really
what
I
want
to
demonstrate
for
you
today.
So
I'm
gonna
show
you
the
event
portal
and
talk
about
some
coping
19
data
streams
and
then
we'll
design
an
app
export
a
specification
and
do
some
code
generation
for
a
spring
cloud
stream
micro
service.
A
So
Before
we
jump
into
that
just
a
little
bit
of
background
information
here.
So
in
the
event
portal,
you
really
need
to
know
about
four
different
things,
so
an
application
domain
which
really
allows
you
to
define
your
different
software
development
teams
or
lines
of
business
or.
However,
you
want
to
organize
your
development
teams.
A
Of
course
you
can
define
your
events
in
many
other
ways
as
well,
and
so
all
of
those
things
will
be
connected
in
the
event
portal,
so
you
can
really
visualize
your
architecture
and
it's
an
interactive
graph.
So
you
can,
you
know
soom
in
zoom,
out,
move
events
around
and
really
have
a
better
experience,
understanding
your
architecture,
man,
for
example,
the
Visio
diagram
that
we
saw
earlier
from
the
National
Airspace
System.
A
So
let's
check
it
out.
So
if
I
come
over
here,
this
is
the
github
repo
that
has
the
Coppage
stream
processing
information
in
it.
So
this
is
publicly
available.
Solace
is
actually
making
this
data
available
for
free
for
anybody
to
use
so
we're
getting
data
from
the
Cova
tracking
project
and
from
John
Hopkins
University
and
essentially
we're
taking
it
from
those
data
sources
publishing
into
follows:
pub/sub,
plus,
and
allowing
anybody
to
create
client
applications
to
receive
that
data.
A
So
once
I
get
into
Saul's
cloud
I'm
going
to
jump
into
the
designer
here
and
we're
going
to
look
at
the
Cova
data
feeds,
and
so
in
the
Cova
data
speeds.
We
really
have
a
few
different
things
going
on
the
first
up
here
is
the
John
Hopkins
data
publisher.
So
this
is
getting
the
John
Hopkins
data
publishing
it
out
and
it's
received
by
cases
regional
splitter
and
a
cases
splitter
that
split
the
data
on
different
things
and
make
it
available
in
different
streams
at
the
bottom.
A
And
what
we're
going
to
use
today
is
information
from
Kovac
tracking,
so
we
have
a
state's
current
value
publisher,
but
that
queries
their
api's
gets
the
latest
information
and
publish
it
and
it
publishes
it
every
30
seconds
or
so.
We
then
have
a
state
splitter
that
is
processing
that
data
and
splitting
it
up
by
state
and
actually
only
publishing
events
when
changes
actually
occur.
So
this
allows
anybody
to
subscribe
to
these
single
state.
Current
data
update
events
and
only
get
notifications
when
things
change.
A
So
you
know
if
things
stay
the
same
for
five
hours,
you
don't
just
get
a
bunch
of
events
that
mean
nothing
for
five
hours
straight,
where
the
state
stays
the
same,
but
instead
you'll
get
an
update
after
five
hours.
On
that
says,
hey,
you
know
the
data
has
changed
for
Florida.
Now
you
can
process
that,
so
you
save
on
network
bandwidth.
You
were
notified
in
real
time
when
something
happened,
and
now
you
can
process
that
event
and
take
action.
So
why
don't
we
add
an
application
here?
A
So
if
I
click
on
an
application,
we'll
go
ahead
and
name
this
application,
coded
tracking
state
test,
a
percent
calculator,
and
so
what
we're
gonna
do.
I
guess,
I'll
show
you
real
quick.
This
is
an
example
event
that
comes
out
on
a
topic,
so
we've
got
comm,
koba
tracking
test
states,
current
update
and
then
CT
for
connecticut.
A
A
So
what
we're
going
to
do
is
take
this
information
and
we're
going
to
calculate
a
percentage
for
each
state
so
because
this
data
is
for
specifically
for
the
state
of
Connecticut
I
will
receive
the
event,
of
course,
where
we
receive
events
for
every
state,
but
will
process
them.
You
know
one
at
a
time
as
they
occur
in
real
time,
so
we'll
say
all
right.
A
Well,
what
we
want
to
do
is
provide
a
new
event
that
will
just
public
publish
the
percentages,
and
so
what
that
event
might
look
like
is
something
like
this,
so
it
might
have
the
state
in
it.
The
total
test
results
on
the
date
checked
and
the
date
modified.
How
many
cases
were
positive
and
negative
from
the
test
and
then
the
percent
positive
and
the
percent
negative?
So
that's
really
what
we
want
to
create,
so
I
generated
the
schema
here
and
so
I'm
gonna
go
ahead
and
copy
that
we
might
use
that
in
a
minute.
A
A
A
A
A
Percent
data
to
so
we'll
click
save
on
that
we'll
save
our
event
must
have
already
had
these
events
from
before.
So
we'll
do
two
all
right
so
now
that
we
have
that
event,
this
it's
marked
as
new.
So
we
want
to
publish
those
events,
so
we
want
to
add
that
as
events
publish
and
click
Save,
so
now
we
can
see
in
our
little
graph
here
we
are
now
publishing
that
new
event,
and
so
now,
as
a
developer,
I
want
to
actually
develop
this
application
and
so
I
have
all
the
information
in
my
design.
A
I
collaborated
with
my
architect
to
make
sure
everything
was
accurate
and
now
I
can
off
obviously
code
list
from
scratch,
but
I
don't
want
to
cut
it
from
scratch.
I
want
to
use
a
sink
API
code
generators,
so
I'm
gonna
go
to
async
API
here
choose
the
ammo
and
click
download
and
what
this
actually
did
is
exporter,
an
async
API
document,
and
so
in
here
under
under
components
it
has
a
bunch
of
different
schemas.
So
we've
got
our
two
different
schemas
one
for
the
input
data
once
an
output.
A
We
have
the
messages
that
are
that
our
application
expects
to
send
and
receive,
and
we
have
the
channels
here
defined
that
we
that
we're
just
going
to
subscribe
to
subscribe
to
receive
the
the
events
coming
in
and
publish
or
the
events
coming
out.
So
there
are
a
few
things
that
we're
still
working
on
with
the
code
generator
here
as
part
of
the
ACE
and
KPI
community.
A
One
of
those
is,
it
doesn't
yet
support
dynamic
topics,
so
I'm
going
to
go
and
get
rid
of
the
dynamic
piece
of
this
topic
and
there's
an
extension
ICS
function
name,
and
so
what
this
will
do
is
call
it
a
calculate
percentage.
Is
it
will
kind
of
it
will
correlate
these
channels
together.
So
when
I
subscribe
to
this
channel
and
receive
an
event
on
there,
my
application
is
going
to
expect
to
publish
on
this
channel
I'm
kind
of
one
event
in
one
event
out
I'm,
building
kind
of
a
a
stream
processor.
A
Here,
I'm
that's
going
to
to
do
that.
I
also
want
to
create
a
destination
name
here
on
access,
key
I
suggest
destination,
so
I'm
gonna
use
the
sauce
binder.
So
by
using
this,
it
will
actually
create
a
queue
for
me
to
make
sure
that
I
queue
up
my
amends.
So
if
I,
if
I
go
offline,
you
know
I'll
still
have
them
to
consume
later,
so
I
wanted
to
do
they're,
tracking
and
then,
let's
see,
I'll
call
this
conquer
the
tracking
and
then
calculate
percentage
dot
key.
Why
not?
A
So
now
we
need
to
do
code
generations.
Let
me
bounce
over
here
to
the
terminal
I'm
in
the
temp
async,
a
PA
API,
comp
directory,
which
is
empty,
and
so
let
me
copy
a
generation
command
over
here.
So
we
all
don't
have
to
watch
me
painfully
type
this
and
so
make
it
a
little
bit
bigger.
So
you
can
see
my
screen
this
clear.
A
A
little
bit
bigger
fit
to
screen
takes
the
command
all
right,
so
this
is
using
the
async
API
code,
general
generator
with
the
Java
spring
cloud
string
templates.
Let
me
actually
show
you
the
template.
Look
like
we're
using
this
template
here,
and
so
this
is
part
of
the
async
API
github
or
you
can
find
it
in
there
and
what
it
does
is
it's
going
to
take
in
a
nascent
API
document
and
output
a
spring
cloud
stream
microservice.
So
you
can
look
at
here
and
see.
A
You
know
how
it
works,
how
it
knows,
what
methods
to
create
what
they're
named,
how
to
use
the
template.
So
all
that
all
that
is
here
as
well
as
some
different
parameters
to
specify
so
for
this,
in
particular,
I'm
outputting
to
the
Cova
tracking
test
percent
calculator
directory
I'm
using
the
solace
binder.
A
I
want
this
to
actuator
to
be
included
in
mine
spring
project,
but
it
is
a
maven
project,
so
we're
gonna
specify
an
artifact
ID
and
a
group
ID
I'm,
specifying
the
java
package,
so
the
generator
is
going
to
take
the
schema
for
the
objects
that
were
included
in
the
async
API
document
and
actually
generate
pojos
from
those,
and
so
those
are
gonna
be
placed
in
this
package.
Then
I'm
specifying
because
I'm
using
the
solace
binder
I
can
specify
my
hosts,
my
username,
my
password
and
the
message.
A
A
Just
make
sure
that
it's
correct,
really
quick
over
tracking
States,
has
percent
calculator,
M
all
correct
all
right
and
I'm,
putting
you
the
template
at
the
end,
so
I'm
going
to
let
that
go
and
run,
and
hopefully
here
will
get
success
all
right
perfect.
So
our
jet,
my
shiny
files,
are
looking
at
here.
So
let's
go
ahead
and
import
those
into
my
IDE.
So
if
I
say
import
general.
A
Temp
basic
API
cough
open
here,
cool
there's,
a
palm,
so
I
hit
finish
and
so
I'm
using
the
spring
tool
sweet.
So
it
will
actually
recognize
this
as
a
spring
project
and
give
me
some
some
book
niceties
to
go
with
that.
So
we
have
got.
We've
got
a
red
X,
but
that's
okay,
we're
gonna
fix
that,
so
the
here's
will
be
generator.
It's
a
regular
Java
project.
We
can
see
everything's
under
our
package
that
we
specified.
A
We
have
these
two
classes
here:
the
Cova
tracking
state,
current
data,
encoding
tracking
state,
current
test
percent
data,
two,
and
so
these
objects
were
generated,
and
so
everything's
all
nice
and
in
here
we've
got
well
everything
that
was
in
the
scheme.
Oh
we've
got
getters
and
setters,
so
we
can
access
the
data.
So
now
we
can
go
ahead
and
just
use
this
to
code
up
our
app
so
application
Java
is
really
where
the,
where
the
function
where
you
write
your
actual
business
logic.
So
we
come
in
here.
A
We
basically
have
an
add
business
logic,
and
so
what
we
want
to
do
is
we
don't
want
to
return
null.
We
want
to
return
input,
we're
going
to
calculate
the
input,
and
so
the
input
here
in
spring
classroom
is
actually
defined
by
this
object
here,
so
we're
taking
in
the
state
current
data
and
we're
outputting
the
state
current
test
percent
data
to
object.
A
It's
really
so
the
output
objects,
what
we
actually
want
to
create.
So
as
part
of
this,
what
we
probably
want
to
do
here
is
get
the
state
quota
that
the
data
is
for.
So
if
we
say
input
dot
get
speed,
you
can
get
our
state.
Why
don't
we
crank
this
out
system,
dot
out
dot
print
line
bomb
state
update
received
for
that
state.
A
In
the
positive
cases,
so
I'm
just
populating
my
my
new
event
right
and
so
so,
you'll
notice
here
that
as
long
as
I
type
I'm,
just
I'm
just
putting
my
business
logic
in
here
right,
I
didn't
have
to
wire
up
any
messaging
stuff
and
the
reasons
about
his
spring
cloud
stream.
Abstracts
a
lot
of
that
from
you.
So
this
is
just
a
regular
spring
bean,
which
is,
which
is
awesome.
It's
really
the
the
benefit
of
using
spring
cloud
stream.
I
don't
have
to
go.
A
A
This,
and
so
essentially,
what
I
did
here
was
add
my
calculated,
he
percent
positive
and
the
percent
negative
I'm,
just
by
dividing
the
number
of
non
positive
cases
by
the
total
test,
results
the
same
for
negative
and
then
I'm
gonna
print
out.
So
the
last
piece
I
wanted
to
look
at
real,
quick
before
we
run
the
app
is
actually
the
application
dot
ela
file.
So
this
is
where
all
the
bindings
in
spring
classroom
goes.
A
So
this
was
generated
from
the
async
API
document
and
put
straight
in
here,
so
the
developer
didn't
have
to
care,
so
it
actually
specifies
our
function,
the
bindings
and
how
they
bind
to
the
different
destined
topic
destinations,
and
then
they
even
put
it
in
all
our
credentials
here
to
connect
to
the
event
broker.
So
now
that
we
have
that,
we
should
be
able
to
just
run
this
as
a
spring
boot
app,
because
spring
cloud
string
is
based
on
spring
boot.
A
My
Mac
has
enough
memory
to
continue
running
there.
We
go
alright
so
to
spring
app
and
it's
running,
oh
I
need
to
make
one
quick
change
actually
remember
earlier.
I
mentioned
that
the
application
doesn't
yet
support
dynamic
topics,
so
I
just
need
to
put
in
a
greater
than
here
to
say,
subscribe
for
everything,
I'm,
also
its
weight
on
to
sit
here
and
wait
for
updates
to
happen
I'm
going
to
subscribe
to
a
test
string
here.
So
let
me
make
those
changes
and
then
run
this
again.
A
A
But
so,
while
we
wait
for
the
events,
I
just
wanted
to
point
out,
you
know
how
this
can
really
improve
the
Avenger
of
an
experience.
Oh
there,
we
go
we're
getting
events,
but
you
can
see
how
quickly
we
went
from
design
to
code,
and
this
was
all
because
of
basic
API
and
the
ability
to
use
the
pub/sub
plus
portal
so
that
I
have
for
you
I
want
to
say.
Thank
you.
Thank
you
for
watching
the
talk.
Thank
you
for
sticking
with.
It
me
the
whole
time
and
watching
my
horrible
coding
skills
as
I
typed.
A
Everything
out.
If
you
want
to
check
out
any
of
the
resources
that
I
used
I've
added
some
QR
codes
here
on
the
screen,
so
it
feel
free
to
scan
these
with
your
phone.
The
first
is
to
try
the
pub/sub
plus
for
free,
so
this
allows
you
to
use
the
pencil
plus
event
brokers
and
also
check
out
the
event
portal
that
I
used
for
the
design
portion.
The
middle
here
is
the
Cova
19
event
stream
github
repo.
A
So
these
are
the
event
streams
that
are
available
for
free
for
anybody
to
use
and,
let's
see
what
you
come
up
with,
let's
see
how
we
can
help
people
analyze
the
Cova
19
data,
and
you
know
improve
things
for
everybody
in
this
time
of
need
and
then
also
on.
The
right
here
is
the
async,
a
PRN
clouds
during
the
code
generator
template
that
I
used.
So
again,
thank
you
enjoy
the
rest
of
AC.
You
sync
API
comp
have
a
good
day.