►
From YouTube: OCB: Camel K and Serverless in Action
Description
When to use them As organizations move workloads to containers and the cloud the need to utilize resources optimally is ever important. Serverless technology allows dynamic allocation of resources as needed ensuring for no under or over provisioning. This is particularly useful for workloads that run periodically or see spikes. Apache Camel is a widely used Java integration framework that in the latest major version begins to utilize serverless technology. In this session attendees will get an introduction to serverless technology and Apache Camel. They will learn how Camel K utilizes it to run natively on Kubernetes platforms as well as how to get started with the technologies. Attendees will also see a live demo of Camel K and serverless in action.
A
B
Hello,
everyone
welcome
to
another
openshift
commons
briefing,
you've
seen
some
of
our
other
sessions
on
serverless
and
we
wanted
to
bring
you
more
workloads
and
more
ways
to
use
serverless
and
openshift,
and
today
we
have
mary
cochrane,
who
is
going
to
present
on
camel
k
and
serverless
and
give
us
a
intro
and
a
demo
and
really
looking
forward
to
this
all
right
mary.
You
want
to
take
it
away.
A
Perfect,
thank
you
so
much
so.
As
I
said,
I,
my
name
is
mary
cochran.
I
am
a
senior
active
solutions
architect,
so
I've
been
with
red
hat
a
little
over
seven
years,
working
in
this
integration
and
application
development
space
most
of
this
time-
and
I
live
in
charlotte
north
carolina.
So
hopefully
today
you
can
learn
a
little
bit
about
camel,
k
and
serverless
and
how
the
two
can
work
together
and
also
how
kmlk
can
work
without
serverless.
A
The
patchy
camel
is
pattern-based
integration
engine
and
it
is
java
based
it's
based
on
enterprise
integration
patterns,
and
so
these
patterns
are
really
design
patterns
that
have
been
used
for
years
and
years
to
do.
Various
data
integrations
data
transformations
and
have
become
kind
of
standardized,
and
with
that
camel
comes
out
of
the
box
with
over
300
components
and
these
components
you'll
see
in
one
of
the
next
screens,
you
can
do
things
from
connect
to
various
aws
services
to
reading
a
file
connecting
with
salesforce
calling
rest
apis
or
creating
rest
apis.
A
A
We
actually
took
a
csv
file
and
kicked
off
a
much
larger
process
based
on
that
csv
file.
So
every
line
in
the
csv
file
was
really
its
own
process
instance.
So
we
used
camel
to
read
that
csv
file
take
each
line,
create
a
process
instance
from
each
of
those
lines
and
also
to
validate
that
it
was
in
a
good
format.
The
data
was
what
we
expected
and
then
go
from
there
with
these
routes.
You
can
develop
them
either
in
java
or
in
xml.
A
Then
we
talk
about
integration
patterns,
some
examples
of
what
those
things
are
are
splitting
up
items.
So
we
talked
about
the
csv
file.
That
kind
of
goes
into
this
first
use
case
where
it
says
split
orders
and
then
send
each
order,
it's
very
similar
to
that
csv
file
where
we
split
the
file
by
line
and
then
send
it
to
different
places.
So
in
this
case
we're
splitting
the
orders
from
a
larger
order
and,
having
each
item
then
say:
okay,
it
neither
gets
to
be
sent
to
an
electronics
area
to
be
fulfilled
or
to
another
area.
A
The
cable
routes,
as
I
mentioned,
you
can
write
them
in
either
java
or
an
xml
on
the
top.
You
have
this
java
example,
so
here
we're
taking
a
file
in
the
folder
data.
The
file
is
named
inbox
and
then
we're
just
sending
it
to
a
jms
queue
named
order
on
the
bottom.
We
have
that
same
exact
route,
just
written
in
xml.
A
The
quarkus
is
what
we
call
supersonic
subatomic
java,
it's
java
modernized
and
made
to
have
low
resource
utilization
really
fast
start
time,
but
then
still
have
the
java
that
we're
used
to.
When
it
comes
to
writing
our
code
and
developing,
it
doesn't
have
any
big
learning
curve
that
learning
a
new
language
sometimes
does,
and
it's
really
made
for
containers.
First,
one
of
the
big
things
with
quarkus
is
the
developer
joy.
The
ability
to
do
live
coding.
A
A
First,
with
that,
fastboot
time
queries
basically
takes
java
and
then,
if
you're,
using
grail
vm,
which
is
essentially
the
virtual
machine
that
is,
was
created
to
be
a
polyglot,
jvm,
so
polyglot
virtual
machine
to
be
able
to
run
different
types
of
languages
and
runtimes,
and
so,
if
you're,
using
gravion
and
using
quarkus,
you
can
actually
compile
the
code
down
to
native
similar.
The
way
to
the
way
you
might,
if
you
were
writing
in
c,
which
then
results
in
this
very
fast
boot
time,
low
memory
utilization
and
it's
a
great
fit
when
you're
running
serverless
workloads.
A
A
When
it
comes
to
the
resource,
utilization
and
startup
time,
if
we
look
at
comparing
our
traditional
cloud
native
stack
so
to
something
like
a
spring
boot
microservice
versus
utilizing,
quarkus,
plus,
open
jdk
or
utilizing
quarkus,
plus,
using
that
grail
vm,
where
we
compile
it
down
to
native,
you
can
see
that
the
startup
time
and
the
memory
utilization
is
drastically
different,
we're
going
from
218
megs
down
to
130
down
to
35..
So
even
if
you
don't
compile
it
down
to
native-
and
you
just
decide,
okay,
I'm
just
going
to
use
this.
A
A
Okay,
how
do
those
two
things
fit
together
and
work
along
with
serverless?
The
camel
k
is
the
said.
This
sub
project
of
the
larger
apache
camel
family
and
it's
really
born
on
kubernetes.
It's
it's
made
to
run
on
kubernetes.
It's
made
to
run
in
containers
and
be
super
lightweight
and
really
work
well
with
serverless.
A
When
it
comes
to
running
on
kubernetes,
you
can
run
it
just
on
vanilla
kubernetes.
You
can
run
it
on
openshift,
which
you'll
see
today,
and
then
you
can
also
run
on
openshift
with
k,
native
and
serverless.
So
I'll
actually
show
both
two
and
three
today
and
see
some
of
those
differences
between
the
two
when
it
comes
to
camel
k
versus
quercus
versus
normal
camel.
Here
we
have
the
camel
three
projects.
Overall,
we
have
camel
k
projects,
so
that's
made
for
camel
and
kubernetes
and
k
native.
A
A
You
know
higher
deployment,
time
and
redeployment
time
and
then,
if
that
binary
lives
somewhere
remotely
even
higher,
if
we're
running
it
just
from
say
my
laptop
to
a
remote,
open
shift
instance,
then
even
higher
and
what's
interesting
about
this,
too,
is
the
deployment
time.
They
initially
still
takes
a
few
seconds,
but
that
redeploy
is
really
pretty
instantaneous.
A
So
how
does
this
work
we've
seen
some
camel
routes?
How
does
it
work
with
openshift
and
camel
k
and
kubernetes
piece
so
camel
in
general
works
traditionally
in
a
java
project,
whether
you
are
running
it
as
xml
or
as
java?
Usually
there's
some
sort
of
project
structure,
tmlk
changes
that
and
switches
it,
and
at
this
point
you
only
have
your
integration
file,
so
you
just
have
a
file
with
either
your
java
code.
A
You
can
also
use
groovy,
javascript
or
xml
as
well.
Today.
I'll
show
you
mostly
java
examples,
just
that's
what
I'm
used
to,
and
I
am
a
java
developer.
As
far
as
my
background
goes,
so
you
have
these
files
in
this
example
we're
saying
from
some
sort
of
timer
every
second
a
route
id.
This
is
nice
for
identification
for
logging
purposes,
those
sorts
of
things
we're
going
to
set
a
header
at
google.com,
and
then
you
know,
send
it
and
then
log
it
camel
k
also
has
its
own
cli
tool.
A
This
is
camel
with
a
k
and
you
can
use
that
to
then
run
your
integration.
So
you've
probably
seen
people
use
the
openshift
cli
tools
before
so
we'll
use
that
as
well
and
then
once
I'm
logged
in
with
my
openshift
cli,
so
oc
login
and
I'm
logged
into
my
openshift
cluster,
the
camel
seat
or
camel
kcli
will
then
use
that
to
say,
okay.
I
want
to
run
this
integration
on
this
openshift
cluster
in
this
project
and
then
deploy
it
from
there
and
then
using
the
operator.
A
A
So
the
camelcore
library
has
a
lot
of
stuff
already
built
in
but
say
you
were
working
with
a
database
and
you
needed
say
a
mysql
connector,
and
so
you
would
need
a
specific
camel
dependency
down
here
in
the
cli.
You
would
just
have
a
dash
dependency
equals
and
then
the
information,
the
artifact
id
for
that
dependency,
and
this
also
allows
you
to
utilize.
If
you
have
say
another
library
that
you've
coded-
and
it
has
say
all
of
your
data
structures
that
you
need.
You
can
make
that
library
available,
saying
something
like
a
nexus
repository.
A
A
So
when
we
deploy
from
that
file,
you
can
also
do
these
live
updates,
so
there's
a
way
to
run
a
dev
mode
or
just
from
a
redeploy.
As
I
said,
it's
pretty
instantaneous
less
than
one
second.
So
that's
normally
the
approach
that
I
do.
If
I
redeploy,
then
it
looks
at
this
integration
custom
resource
that
it's
created
via
the
operator
and
then
the
operator
goes
updates.
A
A
Once
again,
we'll
have
this
file
with
our
integration
deploy
it.
The
operator
goes
okay,
you
want
to
run
this
it'll
say:
okay,
is
there
a
k-native
profile?
If
not,
then
it's
a
regular
deployment.
So
that's
what
you'll
see.
First,
if
there
is
yes,
then
we'll
say:
okay,
we're
going
to
need
to
serve
this,
as
if
it's
serverless
with
our
k-native
serving
some
use
cases
for
kmlk.
A
A
A
I
have
previously
installed
this
operator,
but
if
I
hadn't,
I
can
come
into
operator
hub
search,
camel
k,
you'll
see
we
have
the
community
operator
k
native
one
specifically,
as
well
as
the
red
hat
integration
one.
So
here
I've
installed
the
red
hat
integration
camel
k.
If
I
go
over
my
installed
operators,
you
can
see
that,
and
here
you
have
some
kind
of
out-of-the-box
provided
apis.
A
An
integration
platform
is
needed
to
run
any
camel
k
integrations,
but
in
this
case
it
also
will
automatically
create
that
platform.
As
soon
as
you
deploy
a
camel
okay
integration,
it
also
gives
you
some
descriptions
for
how
you
can
go
about
installing
things
or
writing
your
first
integration.
If
it's
something
that's
new
to
you,
so
in
this
case
go
to
projects,
I've
created
this
project
called
kmlk
on
workloads.
A
A
A
There
we
go
so
here
we
have
my
operator
and
that's
running
as
a
pod
and
then
I
also
have
previously
deployed
this
simple,
rust
service.
So
if
I
go
ahead
and
click
on
that,
you
have
a
route
where
this
is
available
and
so
there's
nothing
at
the
root
context.
But
I
did
deploy
something
at
slash.
Hello,.
A
So
this
is
the
file
that
I
have
for
this
simple
camel
route.
So
I
have
a
rest
api
deployed
at
slash
hello
via
a
get
request,
and
then
I'm
setting
the
header
to
just
return.
Some
plain
text-
and
here
I
have
it
saying
it
transformed
to
a
simple
response
of
hello
world,
and
this
one
looks
a
little
more
up
today,
because
it
already
has
a
few
more
exclamation
points.
B
A
A
Pod
bit
more
narrow,
so
keep
an
eye
over
here
on
this
right
side,
as
I
do
camel
run
simple
rest,
so
this
is
going
to
redeploy
this
integration,
so
we
should
see
it
over
here,
pretty
quickly
we're
already
starting
to
deploy
and
it's
done
come
over
here
we
refresh,
then
we
see
hello,
mary
and
it's
done
so
that
redeploy
is
really
pretty
quick
compared
to
you
know,
building
a
whole
new
maven
project
and
then
creating
the
image
from
the
source
to
image
and
going
through.
All
of
that,
it's
much
more
instantaneous.
A
Native
so
first,
let's
talk
about
what
is
serverless
and
k
native
well,
serverless
is
an
execution
model
code
is
executed
dynamically
by
dynamically
allocating
resources.
So
you
only
have
to
utilize
what
you
need
and
then
you
only
pay
for
what
you
need,
and
it
removes
some
of
the
traditional
always-on
server
aspects,
so
you
can
actually
scale
down
to
zero.
A
As
I
mentioned.
If
you
have
some
sort
of
batch
job
things
like
that,
then
you
can
scale
down
to
zero
and
only
scale
up
when
you
need
to
run
that
batch
job
and
so
k
native
is
red,
hat's,
serverless,
offering
and
primary
component
of
that
there
are
two
components
of
it:
we
have
the
canadian
serving
and
the
canadian
eventing
for
today's
purposes
we're
going
to
focus
on
the
encampment
of
serving,
which
is
that
ability
to
scale
to
zero
and
request
driven
compute.
A
A
A
A
A
A
A
Going
to
need
to
select
this
different
project
so
camel
k,
serverless,
okay
and
now
we
can
use
that
same
camera
run
command
to
deploy
that
same
integration,
and
since
this
is
the
first
time,
I'm
just
gonna
leave
that
to
get
creative.
While
we
talk
a
little
bit
more
about
serverless
and
then
we'll
jump
back
and
take
a
look
at
how
it
all
works.
A
Together
so
we've
deployed
this
integration,
it's
a
rest
api
with
canadian
serving
so
there
shouldn't
be
a
container
if
no
one
needs
it,
but
as
the
request
comes
in
the
pod
will
scale
up,
then
it
will
return
the
request
and
then
the
pod
can
also
talk
to
various
external
systems
if
it
needs
to
from
there
more
requests
come
in.
It
needs
to
scale
up
more
because
there's
higher
load
and
get
more
paws,
pretty
straightforward.
A
And
back
down
so
some
benefits
of
serverless.
If
you've
heard
about
openshift
serverless
before
you've
probably
heard
of
some
of
these
benefits,
but
to
reiterate
get
faster
time
to
market,
you
aren't
trying
to
arbitrarily
predict
how
many
resources
you'll
need,
which
can
lead
to
over
lower
operational
costs.
It
also
can
reduce
your
packaging
and
deployment
complexity.
A
It
comes
to
what
this
looks
like
with
the
no
longer
guessing
how
much
compute
you
might
need
so
without
serverless
you're
kind
of
in
a
spot
of
maybe
you're
under
provisioned
for
most
of
the
time
and
then
for
over
provision
for
most
of
the
time
and
then
under
provision
say
around
holidays.
When
you
have
a
spike
versus
with
serverless,
you
can
simply
scale
as
you
need
it.
A
So
as
we
jump
back
to
look
at
what
camel
k
with
serverless
and
k
native
looks
like,
and
we
saw
camel
cave
running
by
itself,
which
that
fell
more
into
that
just
micro
services,
but
towards
maybe
towards
serverless
as
far
as
microservices
go
and
it
is
using
as
a
corcus
under
the
covers,
and
then
when
we
add
in
k
native
and
we're
using
camel,
k,
corcus
and
k
native
all
together,
we're
really
firmly
into
that
serverless
bone.
And
then,
as
you
can
see,
openshift
covers
all
of
this.
A
So
when
I
started
to
kick
off
that
camel
deployment
earlier,
what
it
actually
is
doing
so
hard
to
see
that
full
screen,
it
is
actually
downloading
the
various
dependencies
from
maven.
So
this
can
take
a
minute
depending
on
where
those
dependencies
are.
This
is
a
demo
cluster,
so
it
looks
like
it
is
taking
a
minute
today
to
find
those
resources.
A
Look
at
over
here
since
I
installed
that
serverless
operator.
We
actually
then
also
have
this
serverless
menu.
You
go
down
and
click
on
serving
right.
Now
we
haven't
deployed
anything
yet
well
we're
trying
to
deploy
something
it's
taking
a
little
longer
to
build
than
it
normally
would.
But
there's
no
services
found
at
this
point,
but
when
you
deploy
them,
you
would
actually
see
them
here
and
then
revisions.
A
B
A
B
B
A
You
can
always
migrate
how
much
of
a
I
don't
want
to
say
pain,
but
how
much
of
a
process
it
will
be,
I
think,
varies
depending
on
the
tool.
So
we
don't
have
any
tooling
today
to
migrate
from
those
specifically,
some
tooling
that
we
do
have
in
professional
services
are
from
typical
business
works.
We
have
some
tooling
to
migrate
from
that
to
traditional
camel
and
the
process
from
traditional
camel
routes
to
camel
k
is
actually
pretty
straightforward.
A
Most
of
the
time
your
actual
routes
are
going
to
stay
pretty
much
the
same.
It's
just
that
then
you're
taking
them
and
isolating
them,
and
then
any
of
the
dependencies.
As
I
said,
you're
deploying
into
some
sort
of
repository,
whether
that's
nexus
artifactory
wherever
that
may
be
so,
then
they
can
use
them
as
dependencies.
A
A
A
A
A
A
Save
it
and
then
I'm
going
to
just
redeploy
it
back
to
that
original
cluster,
and
so
since
we
have
the
server
list
running
now
this
time
since
it
deployed
it's
kind
of
hard
to
see
in
this
view,
but
there's
this
little
k-native
symbol
that
shows
up
to
show.
Okay.
This
is
a
serverless
deployment
now,
and
so
it
starts
up
off
the
bat
with
a
single
pod.
A
It
assumes
that
it
will
need
to
be
utilized,
but
if
we
give
that
a
few
minutes
I'll
hit
it
now
just
so,
you
can
see
that
the
route
you
know
exists,
it
does
what
it
needs
to,
but
then
we're
going
to
just
give
it
a
few
minutes
so
that
it
can
scale
down
to
zero.
So
if
there
are
other
questions,
bring
them
at
me,.
B
C
A
Well,
just
in
time
it
looks
like
it
just
now
auto
scaled
down
to
zero,
so
that
was,
I
don't
know,
maybe
a
minute
of
it
sitting
there
idle
and
then,
if
I
come
back
here
and
let's
just
hit
that
url
give
it
a
second
to
jump
back
over
here,
you
can
see
it's
scaling
up.
So
even
when
it's
scaled
down
to
zero,
you
can
still
hit
that
url
if
it's
a
rest
request
and
it'll
scale
up
and
then
still
get
you
that
response.
A
Obviously
one
thing
to
keep
in
mind:
there
was
a
little
bit
of
a
delay.
So
if
it's
something
that
you
need
that
instantaneous
response
with
you
know
web
browser,
then
yeah
you're
always
going
to
want
to
have
at
least
one
pod
up.
But
if
it's
something
like
more
of
those
batch
case,
use
cases
or
best
job
use
cases
that
I
mentioned
where
it
doesn't
have
to
be
instantious,
you
just
need
it
to
come
up
at
a
certain
time
of
day
and
do
its
thing
and
then
shut
back
down.
A
A
B
A
Yeah
I'd
say,
as
I
said,
batch
shops
is
a
big
one,
camel
k
outside
of
the
serverless
aspect,
a
lot
of
customers.
They
already
have
often
these
micro
services
that
they've
implemented
with
camel,
but
that
they're
in
you
know
maven
project
structure
and
maybe
there's
only
a
few
different
java
classes
in
the
microservice.
You
know
it's
still
pretty
small,
so
a
lot
of
them
are
breaking
it
out.
A
So
doing
things
like
you
know,
if
it
just
needs
to
create
a
database
and
then
send
that
to
a
queue
if
it
needs
to
just
take
from
one
queue,
do
some
transformation
and
send
it
somewhere
else.
So
a
lot
of
the
integrations
that
are
pretty
basic,
that
customers
have
already
had
in
microservices
now
are
just
getting
broken
off
even
further
into
those
individual
files,
and
a
lot
of
that
has
to
do
with
the
benefits
of
you
know.
You
saw
that
fast
re
reload
time.
When
I
redeployed
it
was
pretty
instantaneous.
B
A
A
Yeah,
so
a
camlet
is
basically,
if
you
look
at
that
route,
you
know
there
was
different
components
for
integrating
with
different
pieces,
so
some
of
that
those
pieces
of
code
have
become
somewhat
standard.
So
a
camlit
is
kind
of
like
that
piece
of
code.
That
then,
instead
of
you
writing
it
over
and
over
and
over
again,
is
has
become
reusable
for
connecting
say
to
like
amazon
s3,
like
that's
a
pretty
standard
thing
where
you
say
okay,
I
just
need
to
go
to
this
s3
bucket
with
this
authentication.
A
A
So
with
three
scale
I
don't
know
if
there's
actual,
I
know
there
was
a
component
in
the
works
with
camel
with
rescale.
I
don't
know
if
there
is
that
for
kmlk,
specifically,
but
any
rest
api
that
you
create
with
camel
k.
You
know
you
can
still
manage
that
with
three
scale
and
do
those
aspects,
but
as
far
as
the
component
itself
that
I'm
not
sure
if
that
has
made
its
way
into
the
camelcat
project,.
A
So
any
tracing,
like
you
can
add,
camel
itself
has
things
like
wire
taps,
so
you
can
add
that
sure
to
kimmel
k,
if
you
want
to
do
tracing
for
say
with
openshift
service
mesh
and
utilize,
istio,
jaeger
and
kiali,
and
all
that
to
have
your
distributed
tracing
and
be
able
to
see
where
things
are
going.
You
can
definitely
add
that
in
on
top
of
this,
it
doesn't
really
work
any
differently
than
other
services
within
openshift
for
that
sort
of
tracing,
but
you
can
add
it
on
top.
C
C
Sure
so,
actually
I
just
wanted
to
mention
that
camera
letter
currently
a
hot
topic
in
openshift,
serverless
and
kinetic
itself.
So
we
are
currently
working
on
to
integrate
the
cabinet
as
a
source
for
canadian
and
it's
integrated
on
the
cli
level.
Vr
kn
plugins,
okay-
and
this
is
your
light
tool
how
you
can
manage
serverless
applications
on
the
cli
and
there's
also
integration
in
the
in
the
developer,
console
coming
in
openshift
as
well.
So
just
want
to
mention
that
canvas
is
really
kind
of
a
very
interesting
technology.
B
A
I
mean
anything
that
has
to
do
with
our
integrations
with
kafka,
and
you
know
just
getting
that
to
a
very
streamlined
place,
which
I
know
that
we
as
an
organization,
are
working
on
and
figuring
out
the
best
way
to
do
all
that.
But
that's
such
a
big
story
right
now
in
the
field
of
okay.
We
have
all
this
data
and
we
decided
that
we
want
to
stream
it
and
we
want
to
stream
it
with
kafka.
B
C
Yes,
so
secretary,
I
really
hope
that
more
so
actually,
there
are
tons
of
components
and
I
think
there
are
there's
only
a
subset
of
components
currently
available
as
camelettes,
and
I
really
would
love
to
see
this
portfolio
to
to
increase
and-
and
I
see,
there's
a
lot
of
work
going
on.
I'm
really
super
curious
because
it's,
I
think
it's
one
of
the
easiest
way
how
you
can
create
an
eventing
source
for
for
openshift,
serverless
and
canadian
and
yeah.
C
We
just
need
to
make
it
more
more
popular
and
just
imagine
if
you
could
use
any
of
those
200
300
components
out
there
for
camel
as
a
source.
I
think
this
would
be
super
awesome,
so
this
would
be
something
and
yeah
so
we're
working
on
that
task
and
so
step
by
step.
But
actually
I
think
we
are
in
a
good
way
there
yeah,
I'm
really
looking
forward
to
that.
B
A
A
If
we
have
a
bunch
of
customers
asking
for
feature
a
then
we
know
to
prioritize
that,
so
I
know
that's
a
large
way
that
we
do
prioritize
those
features
and
then,
from
the
accounting
perspective,
any
information
that
you
can
give
the
account
team
on
we're.
Looking
for
this
feature
or
this
connector
so
that
we
can
do
this
this,
and
this
and
really
diving
into
your
use
case,
can
be
very
helpful
because
then
we
can
then
take
that
to
engineering
and
to
the
business
unit
and
be
able
to
talk
about
well.
A
A
Yep,
that
is
correct.
That's
a
very
active
community.
There's
various
email
lists
on
there.
If
anyone
is
looking
to
get
involved-
and
you
know
become
a
contributor-
that's
always
awesome,
then
I
would
say
a
great
way
to
do
that.
Once
you've,
you
know,
signed
up
and
filled
out
all
the
appropriate
forms.
It's
just
to
start.
You
know
if
you
find
an
issue
in
some
documentation,
just
edit
the
documentation
or
if
you
find
a
typo
and
then
it
gets
you
used
to
that
process
as
well.
B
C
Yes,
actually
it's
at
the
moment
it's
so
there
are
certain
kinetic
repositories
which
are
dealing
about
a
camel
k,
source
and
but
actually
what
I'm
working
on
and
might
and
the
working
group
I'm
associated
with
is
the
client
group
and
we
are
working
on
the
plug-in
site
for
cameralets
and
actually
we're
not
only
thinking
about
camelot
and
sources,
but
also
cameras
as
syncs.
So
you
can
also
leverage
cameras
to
to
get
input
cloud
events
and
then
perform
a
certain
action
in
there,
and
so
both
aspects
are
currently
on
on
the
table.
C
A
B
A
A
B
A
Hamlet,
specifically,
I
I
don't
know
I
would
be
hesitant
to
give
a
timeline
on
that
camel
k
in
general
should
be
within
the
year
very
easily,
because
we
are
one
three
one.
It
should
be
like
at
any
point
now.
People
have
been
using
camel
k
in
tech
preview
developer
preview,
all
that
for
over
a
year,
which
tends
to
be
a
good
indicator.
B
A
Sure,
I
would
say
especially
I
mean
if
you
have
access
to
an
openshift
cluster,
definitely
give
serverless
and
kmlk
a
try.
You
may
as
well
play
around
with
it
see
what
you
like
see
if
it
works
for
you
and
if
you
don't
have
access
to
an
openshift
cluster,
then
you
can
always
go
to
learn.openshift.com
play
around
with
some
things
or
talk
to
your
account
team
about
getting
new
access
as
well.
We're
always
happy
to
set
up
workshops,
demos,
all
that
sort
of
stuff.
B
Thank
you
very
very
much.
This
was
great
great
intro,
great
demos,
even
with
maven
not
working
right.
Now
we
figured
it
out.
It's
all
good
and
roland.
Thank
you
for
jumping
in,
and
you
know
into
the
discussion
and
thank
you,
everybody
saying
thank
you
in
chat
too,
and
with
that
we
will
end
and
until
next
time,
everyone
chris.
Can
you
see
us.