►
From YouTube: Serverless stream processing of Debezium data change events with Knative | DevNation Tech Talk
Description
Speakers: Gunnar Morling & Matthias Wessendorf
Come and join us for an (almost) no-slides session around the terrific trio of Debezium, Apache Kafka Streams, and Knative Eventing!
Leveraging Apache Kafka as the de-facto standard for event-driven data pipelines, these open-source technologies allow you to ingest data changes from relational and NoSQL databases, process and enrich them, and consume them serverless-style.
In a live demo, you’ll see how #Debezium, #ApacheKafka, #Quarkus, and #Knative are the dream-team for building serverless, cloud-native stream processing pipelines.
You will learn:
How to stream change events out of your database using Debezium
How to use the Quarkus extension for Kafka Streams to build cloud-native stream processing applications, running either on the #JVM or #GraalVM
How to consume and distribute Kafka messages with Knative Eventing, allowing you to manage modern serverless workloads on #Kubernetes.
A
Well,
welcome
to
another
deaf
nation:
live
I'm
excited
to
have
all
you
guys
here
today.
We're
gonna
have
a
lot
of
fun.
You
can
see
I'm
trying
a
new
camera
setup,
so
we'll
see
how
well
this
holds
up
and
might
actually
fall
apart
on
us
midstream,
but
I'm,
not
the
star
of
the
show.
Today.
Today
we
have
dinner
and
Mateus,
who
are
experts
and
all
this
stuff
called
kafka
que
native
de
B's
iam
kerbin
Eddie's
of
everything
you're
about
to
see
in
this
one.
Second,
it
is
gonna,
be
a
ton
of
fun
and
I.
A
Think
you're
really
gonna
enjoy
it
as
always.
Throw
your
questions
into
the
YouTube
chat.
I'll
pick
them
up
from
there
and
relay
them
on
to
our
presenters
and
also
I'll,
be
passing
links
through
the
YouTube
chat,
so
be
ready
for
that.
You
know
we'll
have
the
demo
links
and
number
one
question
by
the
way
is:
where
are
the
slides
that'll
be
on
the
link
you're
on
right
now,
so
just
be
prepared
for
that.
So
you
know
you
know
what
URL
you're
at
always
you
can
email
me.
A
You
probably
received
an
email
from
me
this
morning
announcing
this
session
as
well
as
our
future
sessions.
If
you
have
ideas
for
other
things,
you'd
like
us
to
do
on
dem
nation,
please
let
me
know
I'll
be
happy
to
try
to
lose
things
out
as
we
schedule
more
of
these
events
over
time
do
look
for
more
master
courses.
A
Next
week
we
took
this
week
off,
but
next
week
we
come
back
with
more
prove,
Danny's,
intro
content
and
then
you're
gonna
see
more
things
scheduled
after
that,
including
our
Kafka
master
course,
and
some
more
more
content
for
our
operators
and
operations
teams.
Everything
coming
in
the
future,
but
right
now,
I
want
to
turn
it
over
to
gunner,
I'm,
Matthias
I.
Think
Matthias
is
up
first,
but
yes,.
B
Bloom,
you
see
good,
slides,
Lauren,
hello
welcome,
so
this
is
another
new
definition
live
session.
Today
we
have
a
little
content
program
here.
Some
very
interesting
use
case
that
leverages
a
few
interesting
aspects
of
modern
development,
we're
going
to
see
how
you
can
actually
achieve
serverless
screen,
processing
using
division
and
it's
changed
data
event
facility
in
combination
with
key
native
and
behind
the
scenes.
We
will
also
see
something
about
a
Pesci
cafe
in
this
setup.
Today
we
are
here
we're
gonna
morning
and
my
tablet
here
personal.
C
Right
all
right,
so
hello,
everybody
welcome
to
this
definition
session.
I'm
super
excited
to
be
here.
Thanks
for
having
us
so
and
I
mean
we
thought
we
wanted
to
talk
about
some
technology.
We
have
here
to
be
iam
and
you
know
our
offering
candidate
and
so
but
then
you
thought,
let's
drive
it
from
a
UK
prospective
right.
Well,
we
that
out
it
scenario
and
we'll
see
how
we
can
address
this
with
the
technology
at
our
hands
and
the
idea
is
with
the
objective
poor
Turkish.
C
We
would
like
to
consume
a
stream
of
temperature
measurements,
so
we
have
like
a
network
of
temperature
sensors.
It's
a
fake
Network
right,
but
we
have
a
stream
of
temperature
measurements
which
are
coming
in
wire
kafka.
We
would
like
to
enrich
this
stream
with
master
data
which
is
coming
from
a
database
so
like
what's
the
name
of
the
sensor
or
the
station,
where
it's
coming
from,
like
to
geo
spatial
coordinates
and
so
on,
and
just
its
threat
to
Kharkov.
Why
are
the
easiest
would
like
to
enrich
to
temperature
measurements
with
this
master
data?
C
Then
we
would
route
this
enriched
stream
to
different
consumers.
So
we'll
see
how
we
can
do
this
using
K
native
and
finally
I
mean
we
always
like
to
see
some
little
contents
right.
So
we
will
show
how
we
can
take
those
values
and
show
them
on
a
map
of
the
world.
So
we
put
all
our
efforts
into
building
just
awesome,
visual
representation
of
the
data.
So
let's
take
a
look
at
what
we
have
planned
here.
C
You'd
be
the
part
of
to
your
fiduciary
right.
That's
what
you
see!
Yes,
right,
all
right,
excellent,
so
yeah,
let's
go
back!
So
this
is
the
overall
solution
here
and
there's
quite
a
few
parts
of
that
right.
So
we
have
to
be
zoom,
cough
cough,
go
connect
and
so
on.
So
let's,
let's
break
it
a
bit
down
and
get
just
go
through
this
in
steps
one
by
one.
C
So
the
first
thing
is
this
measurements:
they
are
coming
right,
so
we
have
like
a
fake
source
of
temperature
measurements
and
they
are
sent
into
a
Pesce
transcript
topic,
so
we
have
Kafka
running
there,
and
but
we
would
like
to
enrich
this
data
with
the
master
data
from
from
a
database
right.
So
we
have
to
impose
this
database.
C
This
contains
the
master
data
of
our
weather
measurement
stations
and
we
use
jeebies
IAM
to
change
the
capture
tool
to
go
to
the
database
tap
into
transaction
log
and
caption
of
the
contents
of
those
mrsa
data
table
there
and
then
it
into
another
topic
into
Kafka.
So
we
have
two
topics
in
Kafka
and
it's
division.
It's
running
in
Kafka
on
connect.
C
So
that's
another
runtime,
which
is
part
of
Kafka
for
operating
those
connect
and
in
order
to
run
all
this,
we
have
set
up
strong,
ceaseless
rimsey,
say
kubernetes
operator
which
allows
us
to
run
and
operate
Kafka
and
connect
and
all
the
surrounding
things
very
easily
on
kubernetes
or
OpenShift.
So
with
all
we'll
talk
about
that
a
little
bit
and
then
but
I
would
like
to
process
those
streams,
and
this
has
got
cough
cough
streams
it's
coming
in.
C
So
we
have
that
and
it
will
process
just
those
two
topics:
I
will
tell
them
it
about
it
and
write
in
rich
data
back
into
another
Kafka
topics,
but
we
have
enriched
temperature
data
there
in
Kafka,
and
then
we
put
data
to
kubernetes
or
so
UK
native,
and
this
is
what
matthias
can
explain
a
bit
more
about.
It's.
B
Right
after
the
previous
slide,
we
had
a
regular
stream
processing
application
that
was
also
running
inside
the
cluster,
transforming
the
data
and
enriching
them.
And
now
the
scenario
that
we
would
like
to
show
is
how
you
can
use
components
like
a
native
to
actually
offer
my
service
deployment
and
that
you
have
some
services
up
and
running
where
you
can
query
data.
That's
sitting
inside
of
your
veggie
classified
so
that
we
use
some
components
from
NIMH
king
ADA's,
on
organization.
We
have
a
Canadian
Kafka
source
there.
B
That
basically
reads
this
search
traffic
vicuna
was
introducing
and
our
customer
source
is
pumping
all
of
the
earth.
Kafka
events
that
are
there's
tons,
fairly
limited,
foul
demons
and
is
publishing
it
to
be
brokered
into
native
eventing
and
on
the
next
slide.
What
we
see
here
is
that
we
can
now
apply
some
trigger.
That's
the
API
called
inkay
native,
which
basically
is
a
filter,
and
you
can
filter
based
on
the
metadata
off
the.
B
Can
then
distribute
it
across
different
services,
and
what
we
have
here
is
in
our
demo
use
case.
We
have
an
application,
that's
also
written
with
carcass,
that's
an
HTTP
webserver
receiving
all
of
the
cloud
events
and
it's
putting
them
into
WebSocket
server
and
also
providing
you
so
nice
that
Lee,
why
you
see
the
graphical
card
there
with
the
temperature
sensors
and
then
through
WebSocket.
You
will
basically
see
an
interactive
UI
where
all
the
measurements
are
in
different
weather
stations
and
then
on
the
next
slide.
B
C
B
C
Right
so
talking
about
it
briefly,
so
we
have
defeated
in
there
right
this
with
change
to
the
capture.
It
means
we
can
capture
all
the
changes
out
of
database
like
portrait,
it's
what
we
are
using
here
or
my
three
political
server
and
on
end
stream.
Those
change
events
into
authoritative
event,
which
deprived
like
the
old
fate
of
wrote,
a
newspaper
all
ends
up.
We
have
shrimpie
or
jobs
running
and
operating
Kafka
and
kubernetes.
So
this
makes
it
very
easy
for
us
to
interact
with
the
clusters
spin
up
new
nodes,
spin
up
connect
and
so
on.
C
We
have
quotas
and
carp,
a
stream
talked
about
that
and
then
finally,
we
have
K
native,
which
allows
us
to
Gail
out
consumers
based
on
the
load
route
dot
week
with
different
consumer
and
so
on.
So
those
are
the
parts
which
we
are
handing
in
this
demo
there
all
right.
So
let
me
go
and
switch
to
the
console
here.
So
can't
see
my
console.
Yes,
all
right,
excellent.
C
The
first
of
all,
let
me
take
a
little
look
into
this
temperature
measurements
topic,
so
I'm
using
a
tool
called
cough
cough
kit,
which
is
an
awesome
tool
to
just
interact
with
kafka
topics
and
people
in
there
and
I'm,
using
this
and
I'm
just
taking
a
look
at
well,
you
so
they're
coming
in
from
our
own
sensors
right
and
it's
just
like
two
poles
of
a
time
step
and
a
measurement.
Well,
you
and
the
message
key,
which
we
don't
see
here:
that's
the
weather
station
ID,
so
we
can
identify
the
source
of
those
measurements.
C
So
this
is
our
top
topic
now
I
mentioned.
I
would
like
to
enrich
this
with
the
data
in
coming
from
the
database.
Well,
let's
take
a
look
into
this
database
and
I'm
using
another
cool
tool
which
is
called
peaches,
yuck
and
I
can't
just
take
a
look
into
my
post
rest
database
here.
So,
let's
see
and
I'm
just
having
this
table
here,
weather
weather
stations.
So
that's
what
I'm
interested
in
and
well.
C
This
is
just
like
the
master
data
of
this
station
of
those
stations
right
so
I
have
the
name
and
ID
I
have
the
coordinates.
Where
is
the
station
and
I?
Have
this
active
through
false
back
so
distance?
You
know,
allows
me
to
enable
or
disable
stations,
so
we
will
touch
on
that
later
on
and
I
have
a
few
I'm
here
in
the
database.
Ok,
so
the.
A
C
There,
let
me
leave
here
now.
The
next
thing
to
do
is
I
need
to
set
up
Gibby's,
iam
and
I
need
to
deploy
a
GPS
and
connector
which
will
get
to
changes
from
this
table
and
send
it
into
the
kafka
topic.
So
for
that
I'm
using
this
strength
e
operator,
so
it
not
only
has
an
operator
which
allows
me
to
say
that
Kafka
and
kapha
connect
there's
also
an
operator
which
allows
me
to
set
up
and
Casca
connectors,
and
this
I
mean
if
you
have
interacted
with
kubernetes
before
you
will
note,
it's
done.
C
Wire
cuts
and
resources
in
custom
resource
types
go
get
one
for
them
connect.
So
let's
take
a
look
and
I
have
this
one
here.
So
this
essentially
said.
Ok,
this
is
a
copper
connector
which
I
would
like
to
deploy
here.
It
had
a
name
and
then
I
have
the
configuration
there,
and
this
is
welded
justic
configuration
you
would
know
from
copper
connect
and
from
the
B's
young
site.
The
host
name
up
to
database
I
have
the
credentials
where
which
I'm
I'm
using
to
look
in
I.
C
Have
this
whitelist
here's
I'm
just
interested
in
this
particular
schema
and
like
a
few
more
things
which
are
not
too
important
for
now,
but
this
is
like
the
random
connector
configuration.
So
let
me
apply
this
so
I
use
keep
cattle,
I
say,
apply
minus
F
to
be
Xion,
and
then
my
cluster
lives
in
a
different
name
space,
so
I
need
to
put
there.
C
It
should
say
me:
okay,
I,
create
this,
so
I
can
take
a
look
now
into
this
connector
so
again
as
they
I
use,
cube,
color,
not
nice,
I.
Think
as
all
those
things
or
artifacts,
which
are
managed
by
strumsy
I
can
just
use
cube.
Cuddle
to
you
know,
explore
the
state
of
effect,
but
I
can't
they
get
Kafka
permit
per
ebook
there.
C
So
jairs
the
one
I
created,
though
we
can
affect
it,
a
bit
more
in
detail.
So
it's
a
inventory,
connector
and
I,
put
it
out
into
Jason
and
just
to
make
it
look
like
store.
I
hide
it
to
take
you
so
here
I
see
my
connector
and
I
have
two
configuration
here
and
I
see
also
two
status
coming
from
the
arrest,
API
of
copper
connect.
So
it's
running
awesome,
but
now
let
me
take
a
look
into
the
carpet
topics
which
exist
so
Kafka
topics
for
opal
managed
here.
C
Well,
let's
take
you
cannot
get
Kharkov,
atomic
and
Kafka,
and
there
should
now
be
a
topic
for
our
weather
station,
so
the
connector
created
what
we
call
an
initial
snapshot
of
this
data.
So
let's
take
a
look
there.
Let's
see,
I
have
this
here
yet
I'm
using
debt
again
and
now
in
this
case,
I
would
like
to
see
this
topic
from
the
beginning,
because
well
no
new
events
are
arriving
there,
as
this
is
just
the
initial
snapshot
data.
C
So
let
me
take
that
Christine
this
here
and,
let's
see
I'll
it
be
party
to
trick
you
again
so
now
here
we
see
the
data
from
the
weather
stations
topic
right,
and
this
is
the
besom
event.
Structure
is
essentially
here
in
the
octave
state.
I
have
like
to
do
new
state
of
those
rows
and
in
this
case
I
don't
have
to
before
stable,
because
it's
just
a
snapshot
right.
So
it's
just
the
current
state.
C
But
if
I
had
an
update
event,
then
I
would
see,
though,
both
before
and
after
and
then
I
have
some
more
like
a
meta
data
like
the
source,
where
this
is
coming
from.
All
right,
I
have
to
stay
on
this
topic
now.
The
next
thing
is
I
would
like
to
do
this
straight
processing
or
emits
a,
but
we
need
to
traffic
up
streets.
C
So
let
me
do
that
and
for
that
I
need
to
deploy
another
application
which
I
have
prepared
here,
and
let
me
do
it
is
first
so
I
just
deployed
its
application,
which
is
another
workers
application.
While
it's
deploying
and
take
a
look
into
the
source
code,
just
very
quickly,
I
hope
you
can
see
my
clip
there's
the
list
of
my
IDE
and
now
with
this
quadcopter
James
extension
is
very
cute,
very
easy
for
me.
C
So
I'm
I
just
need
to
have
a
CD
I
produce
a
method
which
returns
to
topology
of
my
string
top
of
my
three
application
really
and
then,
while
I
take
care
of
managing
it
right.
Good
awaits
all
those
input
topics
which
this
application
needs.
It
could
expose
things
like
metrics
or
health
checks
for
me,
so
just
really
makes
it
easy
to
run
those
applications
for
me
and
I
could
find
also
take
little
run.
Application
in
the
growl
am
a
native
mode
right.
C
C
So
this
just
gives
me
the
current
state
of
this
weather
station
topic
and
I
filter
it
just
on
the
active
stations
that
I
just
I'm
just
interested
with
those
weather
stations
which
are
active
and
then
I
built
a
stream,
a
talk,
a
king
stream
and
business
on
this
temperature
values
topic
and
now,
whenever
there's
a
new
measurement
coming
in
this
stream
will
produce
a
new
value,
I
first,
a
method.
So
this
means,
in
this
case,
I
split
up
two
values.
C
If
you
remember
this
couple
of
time
stamp
and
well
you
so
I
split
it
up
and
I
returned
it
as
a
JSON
representation,
which
makes
it
a
bit
easier
to
produce
down
from
the
station
ID
the
time
stamp
value
and
also
an
icon.
So
my
tears
and
I.
We
are
both
emoji
lovers,
though,
if
I
may
put
in
this
icon
here
right
depending
on
the
temperature
and
just
gets
returned
and
now
I
join
it.
So
I
joined
in
case
frame
was
2k
table
based
on
the
weather
station
ID
and
then
I.
C
Take
this
station
name
and
coordinates
from
the
weather
station
topic
and
just
a
table
and
put
it
into
this
join
result,
but
finally
I
group:
it
an
educated
because
I'm
all
the
interested
in
the
average
temperature
measurement
per
station.
So
this
is
what
this
grouping
and
aggregation
is
doing
here
and
finally,
I'm
writing
out
this.
C
The
result
of
this
processing
application
of
this
protesting
into
another
topic
right
and
there's
now
many
things
more
I
could
tell
about
kafka
streams
and
the
Crockers
extension
like
it's
life
of
coding
mode
and
go
on,
but
for
now
that
should
it
should,
you
know,
be
enough
on
that
one.
So
now
we
can
take
another
look
into
those
topics
and
there
should
be
another
topic
and
indeed
there's
there.
It
is
so
this
means
temperature
values
enriched.
So
let's
take
a
last
look
into
that
one
care
again,
rebellious
and
rich.
C
So
let's
just
take
a
look
there
so
we'd
see
our
stream
processing
applications
doing
something
right
so
I'd
see
now
the
transform
figure
I
got
from
those
little
presentation
and
now
I
have
to
fascia
name
in
here.
I
have
to
average
value,
and
here
I
have
my
icons
in
here
and
everything
else,
though
I
have
now
the
strings
with
enriched
data
and
then
let's
talk
or
let's
head
over
to
Matias
and
let's
talk
about
how
just
now
can
be
consumed
in
8k
native
way,.
B
All
right,
let
me
take
over
the
screen
X-
and
you
should
see
my
terminal
here
so
now
that
we
have
this
application.
That
kind
of
sir
contained
was
the
stream
processing.
We
want
to
kind
of
break
out
out
of
the
cluster
and
would
like
to
have
a
web
application
that
is
accessible
by
everybody
in
the
browser
and
that
they
can
have
an
interactive
map
where
they
can
see
all
of
the
measurements
that
we
have
with
a
nice
than
location
icons
there
as
well.
B
So
for
that
what
we
need
first
is
we
need
some
service
that
is
like
an
ad
serving
service
and
let's
take
a
quick
look
at
my
code
for
this
one
here,
so
I'm
now
using
a
very
simple
Yama
file.
It's
all
you
need
to
do
for
the
deployment
here.
It's
a
service
548
serving
and
very
similar
to
vanilla
services
in
Panetta's.
It
has
a
specification
and
you
can
define
some
image
in
there
and
what
I
do
here.
I
provide
a
container
image.
That's
basically
representing
gona's
meth
application
that
he
wrote
for
this
demo.
B
At
the
end
of
the
day,
this
is
a
web
server.
Listening
on
port
8080
HTTP
and
this
guy
will
get
the
cloud
events
pokes
it
in
and
will
down
store
them
in
the
WebSocket
server,
and
also
this
guy
contains
the
WebSocket
why
we
can
later
see
all
of
them
in
earnest.
However,
I
have
already
deployed
this
one,
but
there's
you
can
see
here
my
name,
space
I.
B
Don't
have
any
map
display
application
running
here,
because
there's
no
HTTP
right
now
on
this
application,
so
Canadians
as
stated
to
zero
and
as
soon
as
we
stick
all
the
pieces
together
listening
on
data
from
Kafka
and
distributing
it
through
the
a
native
broker
to
the
consumer,
then
we
will
see
this
map
display.
Application
will
spin
up,
but
first
things.
First,
let's
take
a
look,
how
we
can
actually
access
the
Kafka
topic
that
we
have
so
for
that
I
have
a
different
Yama
file
as
part
of
the
K
native
project.
B
B
So
this
Kafka
source,
as
a
key
native
construct,
will
access
the
data
that
gunas
streaming
application
did
create
by
using
the
two
other
custom
topics
and
the
outcome
was
stored
into
temperature
values
enriched
and
that's
what
we're
going
to
be
consuming
now.
I
would
saying
already
earlier
what
happens
here
inside
of
the
Kafka
source.
So
every
event
like
native
binary,
Cafe
vendor,
is
read
there.
B
It's
turned
into
a
cloudy
man
and
every
cloudy
event
is
posted
using
HTTP
to
some
endpoint
that's
referenced
here
as
the
sink
and
in
our
case
I
used
a
broker
the
default
broker
of
Kay
native
eventing,
which
is
already
running
in
my
namespace
here.
So
now
let's
apply
this
comforta
source
and
in
my
named
paid
water
here,
what
we
see
there
is
a
cop
got
swords
that's
being
created.
B
B
However,
it
is
just
pushing
the
data
to
the
broker
and
we
still
do
not
see
our
K
native
math
application
coming
up
your
debt
because
we
have
not
yet
applied
a
trigger
or
a
filtering
mechanism
so
that
the
broker
actually
knows
here
is
somebody
interested
in
these
kind
of
messages,
and
then
we
send
them
along
a
particular
interested
consumer.
Let's
take
a
look.
How
this
trigger
API
looks.
I
have
a
trigger
here
and
again.
Some
metadata,
like
I,
gave
it
a
name
and
here
in
therms
specification.
B
I
have
the
more
interesting
parts,
so
I
have
a
broker
and
I
go
for
the
key
native
default
broker
here
and
then
I
have
a
little
bit
more
opportunities
to
filter,
based
on
the
metadata
of
my
cloud
event.
Objects
that
are
coming
in
I
have
my
filter
based
on
the
attribute,
so
every
valid
cloud
event
message
does
have
a
different
type
and
in
our
case
we
are
interested
in
listening
for
kafka.
B
Events
that
came
from
the
que
native
custom
source
I
could
also
do
a
little
bit
more
filtering
that
I'm
only
interested
in
the
key
attribute.
That's
there
the
extension
for
the
weather
station
ID.
So
if
I
would
comment
this
line
out,
I
would
get
only
reservations
from
the
station
with
the
ID
number
seven.
Now,
when
the
filter
is
being
applied,
all
of
the
matching
our
messages
in
this
case,
all
new
custom
messages,
are
being
sent
to
this
subscriber,
which
is
referenced
here
as
a
que
native
serving
service.
And
here
we
go.
B
We
have
our
map
display.
Now
let
me
apply
the
filter
or
the
trigger
now,
once
the
controller
does
actually
reconcile
the
filter.
What
we
should
see
here-
and
we
see
it-
there-
is
a
new
container
it
spinning
up.
It
is
to
Matt
display,
though
the
creative
eventing
broker
is
now
routing
based
on
my
filter.
B
If
we
had
thousands
of
messages
coming
in
here
in
a
millisecond,
I
would
have
seen
much
more
map
displays
back
in
November
I
was
giving
a
demonstration
on
destination
life
about
hey,
natives
and
Apache
Kafka,
and
what
I
used
there
was
a
sample
application,
which
has
a
couple
of
hundred
thousand
messages
streaming
all
over
way
and
I
was
getting
a
lot
of
consumers
there.
Okay,
now
that
this
thing
is
online,
let's
see
what
it
actually
looks
in
the
browser.
Let
me
open
this
dream,
where
I
can
I
need
to
move
it
over
sorry.
B
C
Exactly
so,
if
you
remember
in
my
database
table
with
the
way
of
patience,
I
have
the
option
to
enable
and
disable
stations
right
and
so
right
now,
just
those
few
are
enabled,
and
now
all
I
need
to
do
is
in
the
database.
I
just
can
literally
use
my
sequel,
I
say:
update,
weather
weather
stations
set
active
equals
true,
so
let
me
run
this
and
then
we
should
see
more
well
use
other
also
from
other
stations
coming
in
right.
C
So
now
we
see
Australia
there,
and
you
know
it's
like
there's
one
from
the
US
and
so
on.
So
now
we
see
all
those
stations-
and
this
is
really
a
cool
thing
right,
so
I
just
was
listening
to
or
we
are
listening
to
those
change.
Events
from
the
database
and
now
well,
DBM
captures
disrupt
it
there.
So
essentially
it
puts
the
update
event
up
to
the
Kafka
topic
or
a
stream
processing
application.
It
will
now
put
all
those
stations
into
this
join
the
course
well-known
or
filtered
out
anymore
right.
B
B
Yeah
I
would
like
to
conclude
as
a
family
what
we
have
seen
in
the
demo
year
recapturing
the
picture
from
the
solution
opening
what
we
saw
so
first
there
was
some
temperature
values
already
in
the
opechee
casket
topic,
and
then
we
were
importing
data
for
weather
stations
from
Postgres
database
using
Capezio
and
feeding
that
into
other
topic.
Then
we
use
the
Kafka
streams
API
to
join
those
two
and
then
rinse
them
and
store
them
in
this
enriched
values
topic
and
from
the
end
which
enriches
where
he
was
talking.
B
We
were
feeding
this
information
in
2k
native
and
with
the
API
of
the
broker
and
it's
trigger
or
filter
mechanics.
We
were
actually
able
to
route
this
based
on
specifying
I'm
interested
in
Kafka
events,
and
then
we
were
dispatching
that,
through
the
Quattro's
web
application
receiving
those
events
as
HTTP,
storing
them
in
WebSocket
and
with
WebSocket
the
user.
That
sitting
outside
of
the
cluster
could
basically
see
an
interactive
map
where
all
of
the
current
measures
were
occurring.
B
That,
basically,
is
a
conclusion
of
our
demo.
Here
we
have
a
few
more
materials
around
division.
We
have
a
link
here
for
gunas
repository.
Where
is
test
stuff.
The
last
update
was
a
little
bit
an
hour
ago
and
we
have
some
more
information
about
the
be
iam
and
as
well
as
Red
Hat
OpenShift
service,
which
is
the
opportunity
where
you
can
install
a
native
serving
and
k9
is
eventing
into
your
open
chef,
Oscar.
C
And
maybe
just
one
more
thing
that
I
think
all
those
technologies
which
we
were
covering
here,
like
GPM
Kwaku,
sandstrm
Z
K
made
if
they
all
were
covered
in
other
dedicated
definition,
talks
before
right.
So
if
you
would
like
to
learn
more
about
any
of
those
specific
technologies,
I
definitely
would
recommend
you
go
back
to
the
archive
and
and
look
at
those
sessions
and
which
tell
you
in
more
depth
about
the
individual
technologies.
C
A
Actually,
a
great
point
Gunnar
and
Matias.
Thank
you
so
much
for
that
great
point,
because
if
you
want
more
information
on
strumsy
and
on
Kafka
on
kubernetes,
we
have
dedicated
sessions
on
that
we
have
to
be
ZM
sessions.
We
have
K
native
sessions
the
many
of
these
things
you've
seen
before,
but
what
I
love
is
that
you
guys
brought
it
together
in
a
really
amazing
overall
demo
right,
we're
all
together
supporting
a
certain
use
case.
That
is
super
cool.
We
have
a
couple
moment
minutes
for
questions.
If
anybody
has
a
question,
we'll
wait.
A
C
C
Let's
say
you
would
like
to
take
data
from
AMQP
to
Kafka,
or
something
like
that
then
mutiny
would
be,
would
be
great
if
it's
about
those
stateful,
applicator
or
stateful
logics
right,
like
joining
data
and
educating,
then
I
would
say:
Kafka
topic,
Kafka
dreams,
it's
perfect
for
that
right
and
I
mean
there's
so
many
things
which
we
didn't
discuss
about
it.
So
you
can
do
interactive
query.
It's
like
going
to
cough
cough
strains
and
just
get
the
current
data
and
let's
make
for
a
given
weather
station.
C
So
it
isn't
really
nice
and
I'm
really
excited
about
the
quirkiness
extension
also
because
it
allows
us
to
use
this.
I
already
would
like
to
show
the
dev
mode.
So
you
can
get
interactive
feedback
while
you're
working
on
this,
maybe
not
the
time,
but
then
also
you
can
write
the
quality
M
so
yeah.
This
I
think
qua
quits
and
caca
streams.
That's
really
is
not
combination,
yeah.
A
C
A
One
of
the
thing
I
did
notice
too,
that
you
guys
have
the
broker
and
the
trigger
in
the
kingdom
eventing
right,
and
so
that
is
that
has
come
up
in
different
presentations
before
but
I
think
you
guys
did
a
nice
presentation
of
that
now.
There's
that
the
Neve,
the
reason
you
go
to
the
broker
and
triggers
to
allow
for
the
filtering
as
opposed
to
the
channel
subscriber
or
just
straight-up
eventing,
you
know
source
to
sink.
Could
you
tell
a
little
bit
more
about
the
advantages
of
those
different
techniques?
If
you
will
yeah.
B
Sure,
if
you
go
with
the
model
of
the
talent
subscriber
like
every
event
that
is
on
the
panel,
is
going
to
all
of
this.
Subscribers,
like
every
subscriber,
gets
all
of
the
events
and
with
the
different
approach
from
the
broker
and
the
trigger
is
really
you.
You
have
K
native
broker
as
a
eventing
mesh
there.
So
all
of
your
different
sources,
and
not
just
sources
like
your
your
Java
back-end
application,
for
instance,
that's
running
in
the
kubernetes
cluster,
and
talk
the
broker
and
just
publish
an
HTTP
POST
request
towards
it
submitting
cloud
event
compliant
data.
B
And
then
you
have
really
destroyed
opportunity
that
you
can
Center
based
on
a
few
criterias
of
the
metadata
of
the
envelope
of
the
actual
volume,
and
it
doesn't
do
content
based
skinning
right
now,
but
still
it
gives
you
a
fine
grain
way
to
actually
route
messages
from
different
sources
or
different
origins.
If
you
want
to
specific
subscribers,
so
I
think
that
is
a
really
elegant
way
of
having
like
a
eventing
mesh
and
a
set
of
scenario
instead
of
just
having
the
broker.
That's
already
subscriber
and
channel
API
that
sad
behind
the
scenes.
B
This
infrastructure
is
being
set
up,
so
if
you
have
a
broker,
it
always
has
in
in
the
background
running
a
channel
and
certainly
subscriber
for
it,
but
the
trigger
mechanisms
that
are
applied
there.
So
the
end
user
is
really
usually
just
interacting
with
the
trigger
and
may
also
deploy
a
que
native
serving
service.
And
then
you
say,
okay,
so
to
XYZ
enables
me
routing
to
this
particular
service.
So
that's
really
the
bare
minimum
ad
is.
Did
you
have
to
work
with
yeah.
A
I
think
that's
a
very
important
point
right.
The
triggering
and
the
filtering
mechanism
is
based
on
the
envelope,
not
the
message,
contents,
but
the
mess.
You
know
the
the
headers.
If
you
will,
they
attributes
associated
that
message.
So
that's
an
important
point
all
right.
Well,
we
are
out
of
time.
Well,
there's
one
last
question:
we'll
try
to
get
you
real,
quick
when
you
decide
to
use
WebSockets
versus
sse4a
real
time,
bezel
a
real
time
visualization
with
data
from
Kafka.
So
when
do
you
decide
between
WebSockets
versus
SSE,
Wow.
C
I
mean
so
you're
asking
to
beckon
to
other
person
is
frontage
technology
choice
right
so
to
be
honest,
I
chose
WebSockets
there,
because
this
API
I'm
familiar
with
I,
would
suppose
server-sent
events
are
equally
useful
or
useful
for
that
the
rate
was
just
a
matter
of
my
personal
experience.
I
would
say
and
I
think
those
would
work.
Yeah.
B
Workers
both
service
and
event
would
have
been
perfectly
fine
here,
because
you
just
render
the
output
you
don't
have
like
entered
any
interactivity
from
the
browser
going
back
to
the
back
end.
There,
however,
with
the
Java
API,
understand
out
there
and
it's
a
very
older
API
to
be
mature,
I
I
agree.
It's
kind
of
the
default
choice
there,
but
it's
just
personal.
A
B
A
I'd
say
the
same
thing
is
for
me
right:
I
default
to
web
sockets
when
SSE
would
do
same
same
reason.
It's
just
easier
something
you
know:
okay.
Well,
thank
you
so
much.
We
are
out
of
time
for
this
session.
We've
got
to
go
reset
things
to
get
ready
for
our
next
session,
we'll
be
live-streaming
talking
about
get
ops
here
in
a
moment,
but
do
remember
to
sign
up
for
our
future
events
check
out
those
URLs.
We
passed
you
there.