►
Description
Connecting the World to Knative with Kamelets - Roland Huß, Red Hat
In Knative Eventing, sources are responsible for importing events from the outside world, converting them to CloudEvents, and sending them along to a Knative sink. But creating source support for a backend requires a considerable amount of effort and additional installation steps on your cluster. Kamelets are a new technology that provides a solution for this problem: they are general-purpose connectors from the Apache Camel ecosystem that are ready to use within Knative. Apache Camel is the prevalent open-source enterprise application integration framework that provides connectors to more than 300 systems. This presentation explains how to use Kamelets as event sources in Knative and connect them to your applications. You will learn to install Kamelet support on your cluster, discover Kamelets from a catalog, and how to deploy and manage them with a Knative client plugin or directly with YAML resources. In a live demo, we will see the combination of Kamelets and Knative in action. Get ready and join the camel caravan to connect the world to your event-driven applications!
A
So
hell
hello,
I'd
like
to
have
here
micro,
because
I
need
to
type
okay.
I
hope
you
can
hear
me
well,
so
my
name
is
roland
huss,
I'm
working
for
redhead.
As
a
software
engineer,
I'm
the
work
group,
one
of
the
working
group
leaders
of
the
client
and
until
the
end
of
the
month,
I'm
still
a
toc
member.
Okay,
let's
get
started
today.
We
are
talking
about
canadian
camelots
and
yeah.
So
first,
let's
start
with
this
classic
picture.
I
think
we
already
have
seen
it
quite
a
lot
today.
A
This
is
how
you
can
set
up
eventing
topology
with
a
canadian
k-native.
You
have
a
broker
in
the
middle
and
then
on
the
left-hand
side.
You
have
something
which
kind
of
creates
cloud
events
or
more
like
an
adapter
who
transforms
external
events
into
cloud
events,
pushes
it
to
the
broker
and
the
broker
then
calls
out
to
so-called
sinks,
and
in
this
talk
we
are
going
to
talk
about
the
left-hand
side,
so
how
we
can
create
easily
many
sources
with
the
technology
which
is
called
camelets.
A
We
will
see
that
in
a
second
and
then
we
also
talk
about
things
because
cam,
let's
also
provide
out-of-the-box
things
that
you
can
directly
use,
but
first
of
all
have
a
look
at
the
existing
sources
that
we
have.
So
we
have
four
sources
that
come
out
of
the
box
with
with
every
kinetic
installation
we
have
the
ping
source
and
the
api
server
source,
which
are
kind
of
yeah
scheduling,
source
and
one
some
source
to
connect
to
the
api
server
of
kubernetes.
A
And
then
we
have
some
more
like
general
purpose
sources
like
the
container
source
and
also
sync
binding,
and
you
can
kind
of
connect
your
deployment
directly
with
with
connective
eventing.
Then
we
have
also
some
more
like
maintenance
of
this
under
the
umbrella
of
connective,
which
is
a
handful
like
cogitosaurus
or
couchdb
source,
like
that.
A
You
find
these
also
on
the
canadian
repositories
and
then,
of
course,
there
are
also
live
vendors
like
trigger
mesh,
that
that
offers
sources
out
of
the
box
and
here
for
some
cloud
connections,
and
we
have
already
seen
in
the
other
talks
before
that
other
other
sources
as
well.
But
I
would
say
that
we
have
roughly
maybe
50
to
60
sources
out
there
and
there's
one
so
what
the
problem
with
sources
actually
or
what's
what?
What
I'm
trying
to
to
tell
you
today?
A
So
first
of
all,
we
know
sources
are
the
entry
point
for
cloud
events.
They
are
not
difficult
to
implement.
So
it's
quite
easy.
You
have
a
controller,
then
you
have
custom
resource
definition
where
you
have
a
single
controller
for
multiple
custom
resource
definitions,
but
still
you
have
to
to
to
create
the
crds
and-
and
you
can
use
some
general
purpose
sources
like
the
container
source
or
the
sync
binding.
A
But
then
you
have
lose
some
advantages
like
the
typed
approach
that
you
get
with
a
crd
or
you,
but
you
still
have
to
create
a
container
image
for
that
of
course,
then
the
other
problem,
actually
is
the
discovery,
is
kind
of
difficult
difficult.
You
have.
We
have
the
event
registry,
but
to
be
honest,
I'm
not
sure
how
many
people
are
really
using
it.
So
event
register
means
you
can
or
a
source
can
register
an
event
type
and
so
that
the
user
can
detect
that
event
type
and
find
the
source,
but
a
more
a
bigger
problem.
A
Actually
is
that
in
restricted
environments,
you
are
not
really
it's
not
easy
to
deal
with
cluster-wide
resources
for
a
regular
user.
So
it's
not
easy
to
create
install
clds
on
your
own.
So
if
you
want
to
install
an
own
source
with
a
crd,
you
have
a
problem
typically,
but
even
even
more,
you
often
have
issues
even
to
read
clds.
So
there
are
lockdown
environments.
A
Openshift
is
being
one
of
them
that,
where
you
can't
really
as
a
regular
user,
you
can't
even
list
cluster
wide
resources,
so
you
can't
even
find
out
what
resources
are
available.
That's
that's!
No!
It's
an
issue
and
yeah.
The
question
is
actually:
are
there
alternatives
how
you
can?
How
can
we
avoid
these
issues
and
actually,
let's
have
a
look
to
to
camel
and
how
we
can
can
we
get
to
many
more
more
sources?
A
Actually,
this
is
a
picture
of
things
which
I
would
like
to
have
in
this
native
eventing
sources,
so
that
easily,
as
a
user
can
directly
connect
to
all
of
these
systems,
and
so,
let's
have
a
look
to
camille,
so
some
words
so
kevin.
You
probably
have
heard
about
cameron,
it's
based,
so
it's
an
implementation
of
that
left-hand
book
in
latin
sidebook
with
enterprise
integration
patterns
very
famous
book,
very
great
stuff.
In
there
they
describe
all
all
kinds
of
patterns
that
you
use.
A
If
you
have
integration
scenario
and
chemin
is
more
or
less
implementation
of
these
patterns
in
code,
so
it
comes
as
a
library
it.
Actually
it's
already
older
than
10
years.
It's
still
one
of
the
most
active
apache
open
source
projects.
It's
java
based
so
typically
uses
a
library.
You
have
a
certain
dsl
where
you
can
describe
your
integration
route
and
then
you
have
to
compile
it
into
some
runtime.
A
Typically,
it's
spring
boot
or
it's
qualcos,
and
then
this
runtime
needs
to
be
operated
either
directly
on
your
on
your
server
or
requestration
platform
like
with
kubernetes,
and
the
benefit
here
is,
of
course,
that
over
those
10
years
they
have
really
the
community
created
more
than
340
components.
These
are
components
are
really
kind
of
connect
us
to
external
systems.
So
therefore,
for
incoming
and
for
outgoing
connections-
and
you
see-
we
have
also
a
big
permanent
fan
here
over
there.
This
was
quite
for
some
fun
it
twittered
at
some
time.
A
A
A
It's
really
something
like
you'll
see
in
a
second
next
slide,
which
you
package
into
our
crd,
which
is
called
camelot.
So
this
kind
of
a
type
like
a
high
level
custom
resource
definition
here,
so
you
can
deploy
many
of
the
cameras
and
then
you
can
create
an
instance
of
this
camelet
with
a
at
binding
easily,
and
so,
but
these
are
all-
are
really
user,
manageable
resources.
So
there's!
No!
A
You
don't
have
to
be
cluster
administrator
for
that,
and
actually,
of
course,
ideally,
you
would
have
all
these
340
components
available
as
camelettes
at
the
moment,
they're
around
70
plus
camelets,
that
you
can
directly
use,
but
this
list
is
constantly
growing
in
quite
some
yeah
amount.
So
actually,
let's
have
a
quick
look
how
this
look
like
from
the
code.
So
this
is
a
typical
example
of
of
camera.
By
the
way
who
of
you
does
already
know
about
apache
camera,
one,
two,
okay,
I
would
say
maybe
half
of
the
audience
that's
great.
A
So
then
you
probably
recognize
this
kind
of
definition.
So
this
is
a
written
in
the
java
dsl.
So
it's
a
builder
pattern,
so
you
put
it
into
a
class
and
then
you
can
create
a
route.
In
this
case
you
have
an
incoming
point,
which
is
a
twitter
search
component.
So
behind
this
this
schema
url
schema.
There
is
a
registered
a
handler
and
this
this
would
do
that
actually
the
connection,
and
then
you
have
parameters
that
you
add
as
query
parameters
here
and
finally,
you
can
do
all
the
pattern
stuff
here.
Is
it
on?
A
You
can
transform
them.
You
can
enrich
them,
you
can
split
them,
you
can
send
them
out
to
something
else
and
here
we're
sending
out
directly
to
an
eventing
broker.
So
super
simple,
but
still
you
don't
have
to
do
a
lot
of
boilerplate
here
in
chemical.
This
would
look
like
that.
So
actually,
this
was
beer
integration,
custom
resource,
and
I
only
have
shown
here
really
only
a
fragment
of
the
specification.
So
you
have
the
configuration
here
with
the
concrete
values
and
then
you
have
the
route,
which
is
actually
more
less
the
same.
A
What
we
have
seen
in
the
slide
before
and
now.
Finally,
we
have
camera
k
and
chemical
just
split
up
the
integration
in
the
template
part
in
an
instantiation
part.
So
actually
the
template
part
is,
on
the
left
hand,
side.
This
is
actually
the
real
camelet
and
you
see
that
in
the
on
the
template
specification,
you
have
placeholders
like
access
token
keywords.
A
So
this
is
about
the
slides.
Now,
let's
go
to
the
demo.
I
have
that's
good.
I
have
50
minutes,
so
we
will
try
something
from
scratch.
Hopefully
it
will
work.
So
we
start
with
a
with
a
twitter
incoming
twitter
searcher.
This
is
a
camelot
component
that
searches
for
on
twitter
for
a
certain
keyword.
In
that
case
it's
a
slash,
key
doc.
It
will
create
then
a
cloud
event
send
it
over
to
the
creative
broker
and
the
kinetic
broker
then
moves
it
on
to
a
creative
function.
A
We
will
also
see
how
we've
also
created
the
function
or
by
from
scratch.
The
function
itself
communicates
with
the
google
api,
a
google
cloud
translation
api
to
translate
the
tweet
into
a
random
language.
Then
we
create
another
cloud
event
sends
it
back
to
the
broker
and
finally,
it
lands
in
the
so-called
slack
sync.
So
this
is
the
opposite
of
a
source
where
we
send
out
this
translated
tweet
onto
a
channel
on
the
canadian
slack
okay.
So
let's
get
started
much.
We
have
not
much
time
and
yeah.
A
A
I
have
to
take
off
my
classes,
okay,
so
that
was
easy
and
now,
let's
start
with
the
twitter
search
component,
for
that
we
can
just
before
I
do
that,
I'm
just
showing
you
all
the
camelets
that
are
listed
here
on
the
cluster.
We
have
also
4k
and
a
plugin
for
camelets.
You
can
do
everything
what
I'm
doing
here,
also
with
the
army
files,
of
course,
but
he'll
be
just
listing
all
the
camelettes
that
you
are
available
it's
over
70.
A
I
say
they
are
really
for
all
kind
of
external
systems
and
one
of
my
favorite
one,
but
we
don't
see
that
much,
but
you
can
try
it
out
chuck
norris
source,
which
gives
you
some
random
chuck.
Norris
quote
very
nice
very
useful,
but
we
are
looking
for
this
twitter
search
here.
So
this
is
our
source
that
we
are
going
to
instantiate
now.
A
So
let
me
do
that,
so
you
can
also
use
source
camelet
and
for
that
we
need
to
create
a
binding.
So
what
you
see
here
now
we
create
a
binding
which
we
call
twitter
search
source.
We
connect
it
to
the
default
broker.
We
set
some
properties
here,
so
these
are
key
value
pairs
that
we
can
use
so
keywords
we're
looking
for
for
this
kdac
and
then
we
are
adding
the
access
tokens
for
our
twitter
api
access,
so
they
are
stored
in
some
files,
so
here
on
the
below
the
directory.
A
A
It
detects
this
camelot
binding,
creates
the
integration
object
and
then
runs
a
compilation
for
the
java
code
behind
the
scenes.
So
then
creates
an
image
that
gets
deployed
directly
to
our
system,
so
this
might
take
a
little
bit.
Hopefully
I
have
already
pre-rounded
all
caches.
So
normally,
if
you
start
the
first
time,
it's
a
little
bit
slower,
but
you
see
already
also
you
see
already
here
that
that
it's
running
and
yeah,
that's
it.
A
So
now
we
have
a
connection
to
twitter
and
get
already
the
tweets
into
our
broker
and
to
to
see
that
this
really
works.
Let's
create
a
simple
e-display
service
or
the
standards
we
have
already
seen
the
service,
which
is
a
server
that
just
logs
out
cloudy
events
to
the
to
the
console,
and
then
I
have
course
to
create
a
trigger.
A
A
A
So
I'm
hoping
that
we
will
come
up-
and
here
you
see
so
now
it's
creating
something
and
we
get
our
cloud
event.
So
you
see
that
the
twitter
searches
creates
a
very
verbal
cloud
event
with
all
the
metadata
that
you
can
get
back
from
from
from
twitter,
and
here
we
have
our
test
text
like
we
have
here.
Okay,
so
works
next
step
is
now
the
slack
sync,
so
we
have
the
twitter
source.
Now,
let's
go
to
the
slack
sync.
A
Unfortunately,
kn
doesn't
has
yet
support
for
camelot
syncs,
but
so
I
can
show
you
actually
the
yaml
file
here
for
such
a
camelet,
and
let
me
so
this
is
the
slack
sync
here.
It's
also
quite
simple,
so
you
give
it
a
name.
You
have
two
two
legs
here,
so
the
source
is
actually
what
you
want
to
connect
to.
A
In
our
case,
we
want
the
source
of
the
broker
because
we
received
the
event
from
the
broker
and
we
filter
also
on
on
tweets
three
translated
types
and
the
other
parties
are
sync,
which
is
just
a
sync,
sorry,
a
camelet,
slack
sync
and
we
configure
it
with
the
configuration.
I
have
not
shown
the
url
here
fully,
so
this
is
the
also
complete
authentication
against
the
slack
channel,
and-
and
yes
that's
it,
that's
all
what
you
need.
So
let's
try
that
as
well.
A
So
I
make
here
apply
minus
f
sync
demo,
so
this
just
includes
the
proper
credentials
and
you
will
see,
then,
if
I
make
this
a
little
bit
larger,
the
sorry
the
binding
as
well.
Oh,
it
already
comes
up
here.
You
see
this
lexing,
so
this
is
actually
the
sink
itself
is
implemented
as
a
canadian
service
because
it
actually
can
also
go
down
its
stateless,
and
so
we
have
now
a
slack
service
here
and
of
course,
we
can
try
that
out
as
well.
So
let's
use
our
event
plugin
for
that.
A
Okay,
and
we
have
already
seen
that
in
action
here,
we
want
to
send
it
to
the
broker.
We
have,
of
course,
set
a
type
to
be
translated
and
we
add
some
random
body
here
and
if
I'm
doing
that,
one
second
going
like
here-
I
have
my
my
slack
here.
So
this
is
the
channel
I'm
going
to
post
to
this
is
on
okay
native
and
what
this
plugin
actually
does.
A
It
creates
a
container
within
the
cluster
that
sends
directly
the
cloud
event
to
the
broker,
because
the
broker,
of
course,
is
not
exposed
to
the
outside,
and
so
you
can
directly
now
send
into
the
slack
channel.
Okay,
now
proven
select,
sync
is
already
working
now,
let's
do
our
final
thing.
This
is
actually
creating
the
function.
I
yeah
there's
still
some
time
for
that.
So
what
we
are
doing
here
now
is,
of
course,
we
create
a
function.
So
actually
we
are
using
node
as
our
runtime.
A
We
want
to
the
cloud
events
template
which
already
provides
a
nice
signature
for
cloud
events,
and
we
call
that
thing
translate
tweet
and,
as
I
mentioned,
we
want
to
talk
with
the
google
translation
api.
For
that
we
of
course
need
to
authenticate
ourselves
and
the
google
cloud
api
typically
work
that
you
expose
certain
environment
variables
which
points
to
our
authentication
file.
A
For
that
we
first
have
to
create
a
secret.
Sorry
group
control
create
secret.
I
have
it
here.
This
is
taken
from
that
file.
So
here's
my
google
service
account
included
and
I
create
a
sql
secret,
which
is
called
google
as
a
and
this
will
be
exposed
to
the
function
within
an
environment
variable
okay.
This
is
created
now,
let's
enter
our
google
translate
suite.
A
In
order
to
talk
to
the
google
cloud
api
translation,
we
need
to
install
a
dependency
which
includes
the
the
google
cloud
api
into
our
function
itself,
so
we
use
npm
for
that,
just
as
a
regular,
node
node
coder.
Hopefully
it
should
be
done
easily
again.
I
will
get
probably
here,
outed
error.
I
won't
fix
it
yet.
A
Okay,
and
now,
as
I
mentioned,
we
need
to
configure
our
function.
Luckily,
there's
also
a
feature
which
is
called
func
config
and
we
would
say
we
want
to
create
a
volume.
We
want
to
add
a
volume
and
we
want
to
edit
form
a
secret.
So
actually,
this
will
add
something
to
your
function
that
you
mount
from
a
secret.
We
take
the
google
sa
which
I
just
have
created
in
my
namespace
and
then
I
have
to
to
point
to
the
sorry
to
the
directory.
A
I
want
to
mount
it
to
and
I'm
using
opt
slash
pce
in
that
example,
and
finally,
we
need
to
add
some
environment
variables
at
so
we
add
it
here
like
that
and
we
use
the.
I
have
to
look
that
up.
I
don't
google
application
credentials,
so
this
is
the
variable
which
is
picked
up
by
the
dependency
for
google
cloud
translate,
and
we
say
we
want
here
our
mounted
directory
plus
the
the
credentials
here,
so
that
one
okay
looks
good
and
finally,
we
need
a
final
variable.
We
add
here.
B
A
A
A
Okay,
we
don't
need
the
sample
code,
even
okay.
Now,
let's
get
started
so.
First
of
all,
I
have
to
to
import
my
dependency
to
google
cloud
translate
and
then,
as
I
mentioned,
we
wanted
to
translate
into
kind
of
a
random
language.
So
actually
I
have
here
an
array
with
different
languages,
they're
all
from
my
fellow
team
members
here
and
okay,
that's
here
and
now
we
we
extract
the
tweet
data
from
the
event.
The
event
that
is
coming
in
is
based
on
this
schema
from
the
twitter
tweet.
So
we
pick
up
this
tweet.
A
We
create
this
sorry,
this
random
number
here.
This
is
just
yeah
picking
some
random
number
from
from
this
array,
and
then
we
do
the
translation,
so
we
have
here
a
translate
object.
This
is
all
given
by
the
google
cloud
translation
api
and
then
we
call
translate.
We
could
also
call
detect
or
another
function
that
is
exposed
by
this
api.
Then
we
enter
the
text
in
here
and
then
we
enter
the
language
code
that
we
want
to
translate
to.
So
this
is
the
one
which
is
picked
up
randomly.
A
A
Okay
and
then
now
we
have
the
text
now,
let's,
let's
create
the
the
actual
text,
what
we
want
to
to
post.
I
have
to
make
a
little
bit
nicer
here,
so
here
you
see
I'm
using
the
original
tweet
text
and
then
I
add
the
translation
like
here
and
then
put
a
nice
flag
in
front
of
this,
so
this
is
also
picked
up
from
the
initial
array.
And
finally,
we
have
to
return
that
here,
which
means
I
have
to
set
the
type
to
be
translated,
and
then
I
have
here
tweet
three
translator
for
for
this
source.
A
Okay,
this
is
the
this
is
the
code
that
you
need.
So
you
see,
this
is
really
kind
of
this
glue
code
that
you
typically
also
see
for
lambda
functions
and
where
you
really
connect
two
different
services
together
and
add
some
extra
functionality
like
like
here
like
translating,
of
course
you
could
do
any
call
out
to
any
other
service.
A
Okay,
let's
go
back
here
and
of
course,
we
won't
first
to
try
it
out
here
locally.
So
it's
not
always
it's
always
if
you
want
to
develop
with
with
against
the
cloud,
it's
all
often
easier
to
really
to
test
and
try
locally
for
that,
I'm
just
have
to
to
source
the
environment
variables
locally
here
as
well.
So
I
have
I've
set
it
in
this
in
shell
file
and
then
I
can
use
npm
start.
I'm
running
this
in
the
background.
A
So
here
it's
running
now
locally
my
function
and
then
I
can
just
again
leverage
my
event
plugin
in
this
case
I'm
sending
directly
to
a
url
and
the
url
is
here:
it's
localhost
8080..
So
I'm
sorry,
I'm
jumping
the
top.
So
it's
easier
to
see
and
I'm
just
adding
some
fake
information,
all
the
data
that
I
needed
in
my
function.
So
you
don't
have
to
provide
a
full-blown
tweet
tweet
cloud
event,
but
actually
only
that
one
and
if
I
send
that
in
in
there
I
have
something
wrong.
A
Ratio,
google
application
credentials
looks
good,
so
I'm
not
sure
why
it
doesn't
work
because,
but
nevertheless,
okay,
I
can
check
it
later,
but
as
you
see
it
already
points
to
the
path
which
is
inside
the
builder
image.
So
let's
keep
finger
crossed
and
deploy
it
as
a
function
at
the
moment,
and
for
that
I'm.
A
A
Oh
really
strange:
okay,
let
me
try
to
deploy
it.
So
actually
you
have
already
seen
how
you
can
deploy
such
a
function.
Let's
go
to
ok
and
func
deploy,
so
this
will
build
the
function
locally,
where
my
local
docker
daemon
sends
it
to
docker
io
and
then
will
deploy
the
image
as
a
service,
creative
service
and
yeah.
This
might
take
a
little
bit.
A
Okay,
now
it
has
been
built,
and
now
it's
pushed
to
the
written
registry
and
before
then
the
connective
service
is
correct.
You
will
see
this
at
the
top
as
well.
You
see
also
that
the
twitter
source
is
really.
This
is
a
true
deployment
because
it
has
to
pull
regularly,
so
you
cannot
really
have
it
scaled
down
to
zero
there.
In
the
future,
there
are
plans
to
combine
cater
for
certain
sources
as
well
with
camelot,
so
that
you,
for
example,
for
the
kafka
source
kafka
camelot.
You
also
can
spin
down
that
deployment
directly.
A
A
Trigger
sweet
translate,
so
actually
we
have
to
filter
on
type
or
apache
camera
event,
so
this
is
the
standard
type
that
camelets
are
exposing.
You
can
override
this,
but
this
is
good
enough
for
us
now
and
then
we
are
pointing
it
to
the
our
our
function.
So
actually
we
connect
now
the
twitter
source
with
our
function
actually
like
that
and
yeah,
and
now
this
kind
of
is
it
now,
let's
check
whether
this
really
works
as
expected.
A
A
I'm
let
me
jump
back
so
sorry
that
the
local
experience
was
not
working
as
expected
yeah,
but
I
hope
I
could
show
you
that
it's
really
super
easy,
that
you
can
create
fancy
integrations
with
tons
of
sources
combining
with
functions
and
yeah.
So
this
is
really
the
kind
of
at
least
from
the
final
setup
lambda
experience
that
I
could
think
that
for
the
future
you
will
see
more
and
more
like
that.
A
A
You
see,
you
have
some
general
purpose
properties
key
value
pairs,
but
since
the
schema
is
also
exposed
by
the
camelet,
you
can
easily
create
dynamically
cli
options
that
that
honor,
this
the
schema
and
also
support
for
secret
and
conflicts
maps
directly
in
our
in
the
candidate.
At
the
moment
they
are
just
literally
included
the
the
secrets,
but
camelots
themselves
already
support
the
secrets
and
contract
maps,
but
not
the
client
itself
had
yet
and
of
course,
we
want
to
have
more
and
more
and
more
cabinets
and
things
and
sources.
A
So,
but
this
creating
such
a
camel
is
a
super
easy
process.
You
just
need
to
do
that
and
finally,
as
I
already
mentioned,
there
will
be
at
some
point
in
time
some
integration
with
cada,
where
you
can
also
scale
down
the
camera
sources,
of
course
only
for
those
sources
that
for
which
cater
scalar
is
available.
A
C
The
event
type
accepted
by
the
sinks,
so
you
know,
if
you're
a
developer,
trying
to
do
this,
you
know
how
would
you
go
about
you
know
finding
the
schema
of,
like
you
know,
tweet
the
text
right,
that's
right,
you
know
and
then
tweet
that
translated
to
talk
to
slack.
You
know
it's
not
it's
not
easy
right.
Yeah.
A
So
so,
there's
not
really
a
schema
registry
for
that,
so
actually,
because
actually,
the
the
cameras
work
that
they
more
or
less
hand
over
directly
everything
that
they
get
from
the
upstream
source,
for
example
like
to
the
api,
and
what
I
recommend
is
the
workflow
that
I've
just
shown
where
you
say
you
just
really
try
examine
the
tweet
like
from
the
source.
You
just
look
at
that
and
pick
up
what
you
are,
what
you're
interested
in
and
then
really
create
your
function
around
that.
A
So
actually
it's
really
at
the
moment,
still
kind
of
a
exploring
thing
where
you
still
have
to
try
out
and
have
to
test
it.
So
there's
no
documentation
for
that,
but
it's
at
the
moment.
So
it's
super
easy,
so
actually
to
be
honest,
80
of
the
demo
was
to
find
out
how
to
authenticate
against
twitter
and
slack,
because
this
was
twitter.
Some
you
need
a
developer
account
for
that
and
you
need
to
increase
your
developer
level
and
whatnot
so,
but
but
yeah
so,
but
the
other
thing
was
more
the
easier,
easier
part
yeah
thanks.