►
Description
Chapters
0:00 Introduction
5:02 Demo time
18:30 Running locally
27:00 Cross-component typed-client
40:50 TestKit Mocked Topic
1:11:23 Kalix Container Registry
1:24:50 Final Remarks
In the dynamic realm of cloud-native application development, optimizing efficiency and productivity is of paramount importance. Developers continually seek ways to streamline processes, achieve seamless local development, and accelerate feedback cycles. In this webinar, we will delve into the recent enhancements in Kalix, showcasing its features that expedite the application building and deployment process. Join us as we demonstrate how Kalix empowers developers to transform ideas into production-ready services capable of serving thousands of requests per second.
A
Let's
get
started
so
if
you're,
a
software
developer
or
if
you
work
in
the
industry,
probably
come
across
a
similar
diagram
where
we
describe
the
typical
software
development
cycle
and
regardless
of
the
methodology
that
you
use
to
develop
a
software,
you
typically
go
and
and
go
through
these
phases
when
developing
a
solution
to
a
problem.
So
you
start
by
and
by
understanding
what
exactly
is
the
problem
that
you're
trying
to
solve?
Then
you
come
up
with
the
solution
and
then
you
start
implementing
and
testing
and
eventually
deploy.
A
So
in
the
first
group
we're
talking
about,
for
instance,
the
introduction
of
a
single
command
that
allow
you
to
run
the
calyx
Service
Plus,
the
proxy
both
and
the
fact
that
now
the
logs
are
written
in
plain
text
for
local
development
instead
of
Json,
which
allows
you
to
read
them
and
understand
them
much
much
easier
and
also
the
introduction
of
a
new
types.
Client
for
cross-component
calls
we'll
see
how
to
use
it
later
and
also
the
test
kit
mocks
topic
that
allows
you
to
test
your
Integrations
with
a
broker
much
easier
than
before.
A
Additionally,
we
also
introduced
native
irm
proxy
images
so
that
your
tests,
your
integration
tests,
run
much
faster,
so
I'd
say
that
the
first
three
points
in
this
in
this
group
are
mostly
related
with
implementation
phase,
and
then
you
have
the
the
last
two,
the
test
kits
and
Native
irm
images
that
are
more
related
with
the
testing
phase
and
then
for
the
CLI.
We've
also
introduced
this
new
calyx
container
register
that
allow
you
to
deploy
your
application
in
an
easier
fashion
than
before,
so
to
demonstrate
all
these
features.
A
What
we'll
do
in
this
webinar
is
try
to
build
a
URL
shortener
API.
You
probably
have
come
across
this,
but
this
will
be
a
very
simple
API
with
the
following
use
cases.
So
the
user
provides
a
URL
to
be
shortened
and
receives
the
identifier,
so
it
will
basically
send
a
post
request
with
the
URL
and
we'll
return,
the
short
URL,
so
that
the
user
can
then
use
that
identifier
and
get
redirected
to
the
original
URL.
A
A
So
if
you
look
at
eye
level
component
view,
what
we'll
have
is
something
like
this
we'll
want
to
have
a
short
URL
controller
that
will
receive
the
request
from
our
users,
so
we'll
have
two
type
of
requests,
create
short
URL
and
use
the
short
URL
and
we'll
make
sure
to
generate
our
short
ID
here
on
this
controller
and
then
forward.
These
calls
to
the
Event
Source
entity
that
will
use
to
basically
register
all
the
changes
that
happen
in
the
accesses
that
that
happened
to
that
URL.
A
A
B
A
B
A
A
new
project
called
URL
chartner.
If
you
still
remember
our
design
session,
we
agreed
that
we
would
be
creating
three
different
calyx
components:
two
actions
and
one
Event
Source
entity,
so
I'll
go
ahead
and
start
by
creating
these
event
certain
event
sourced
entity.
Sorry,
okay!
So
let's
create
this
entity,
also
increase
the
font
size
a
little
bit.
Okay,
so
we'll
have
an
Event
Source
entity.
A
B
B
A
Probably
model
it
as
the
URL
okay,
what
else
do
we
need?
Okay?
So
for
the
events
for
the
URL
created
event,
I
think
we'll
need
to
move
on
to
have
generated
string.
Id
I'll
also
add
the
generated
ID
here
this
will
be
a
uid
and
then
the
short
you,
the
short
ID
and
then
the
URL
or
the
general
URL,
and
we'll
probably
also
want
to
have
a
timestamp
of
when
the
the
creation
happens.
B
A
Doing
okay,
so
here
now
we
have
what
we
are.
What
I'm
creating
now
is
actually
the
the
Handler
of
the
commands,
so
I
need
to
have
an
endpoint
that
I
can
hit
to
create
a
new
URL,
so
this
will
be
a
great
URL,
CMD,
okay,
something
like
this
and
we'll
need
to
say
this
is
this
will
be
a
post
request
right
to
the
create
endpoint
so
to
reach?
This
will
be
slash,
U,
slash
this
shirt,
ID,
slash,
create
and
then
we'll
use
this
body
create.
A
B
A
A
A
B
A
A
Okay
yeah,
so
what
are
we
doing
here?
Creating
an
endpoint,
slash,
shoe,
slash
the
shirt,
ID,
slash,
create
and
we'll
be
meeting
a
new
event
and
then
replying
with
a
show
timing.
Obviously
so
so
here
on
the
short
URL
entity,
we're
assuming
that
we
will
receive
the
shirt
ID
from
the
other
action
that
will
be
building
up
in
a
moment.
A
B
A
Here
we
won't
have
any
any
parameters,
we
won't
have
any
parameters,
but
what
we'll
do
here
is
we
need
to
reply
with
the
specific
status
code,
which
is
the
301
to
say
that
is
permanently
moved.
The
resource
is
moved
and
we
need
also
to
add
another
with
the
location
and
the
new
location
of
the
item.
Yes,
so
that
the
browser
will,
what
we'll
do
automatically
is
just
when
we
access
this
link.
It
will
automatically
redirect
this
to
to
there.
Okay,
okay,.
B
B
A
Okay,
so
we
have
the
metadata
that
we
want
to
return.
You
have
to
reply.
Okay,
I
think
this
is
the
basic
that
we
need.
What
am
I
missing:
okay,
yeah.
Another
thing,
maybe
I
need
to
to
just
say
that,
and
if
someone
tries
to
use
to
reach
for
an
endpoint
that
doesn't
exist,
maybe
I
want
to
add
something
like
this
and
say:
you're
not.
This
exist.
A
B
A
A
That
seems
reasonable,
so
I
think
it's
probably
time
for
us
to
test
this
right.
So
one
of
the
things
that
I
mentioned
is
that
we
introduced
this
new
command
that
allow
you
to
run
both
your
user
function,
both
the
killing
service
and
the
proxy
in
the
same
command.
We
can
do
that
by
doing
k-lix
run
all
this
will
basically
run
your
user
function.
Your
Galaxy
Service
Plus
run
this
Docker
compose.
So
here
we
have
an
error:
let's
see
what
what
the
problem
is:
okay,
yeah.
So
this
is
a
problem
with
my
my
local
environments.
B
A
A
B
B
A
See
if
you
are
located
this
time,
okay,
so
this
is
running
now-
you
can
see
here
that
we
have
some
logs
that
are
coming
from
the
user
function.
Let
me
try
to
increase
this
a
little
bit,
so
you
can
see
it
better.
You
have
some
logs
coming
from
the
user
function.
You
also
have
some
logs
that
come
from
the
docker
compose
file
that
is
running
so
the
proxy.
Basically,
so
we
have
all
these
on
the
same
command
line.
A
A
A
B
A
A
A
A
Another
thing
that
I
that
I
didn't
mention,
but
yeah
you
can
pretty
much
see
here,
yeah
we're
basically
we're
now
logging
all
this
information
in
plain
text,
which
is
obviously
much
easier
to
to
go
through
than
before,
where
we
were
using
Json
here
as
well.
So
now
you
have
this
by
default.
We
are
using
this
log
back
Dev
mode
in
which
we
are
using
plain
text
to
to
log
all
stuff,
okay,
yeah.
A
A
If,
if
you
I
don't
know,
for
some
reason
would
rather
have
the
docker
compose
always
running
and
just
restart,
there
is
a
function
for
some
reason.
This
can
be
useful
to
know.
Okay,
so
if
I
stop
here,
I
can
leave
the
this
one
running
without
the
issues
and
just
and
just
just
restart
it
I,
don't
know
why
this
is
not
working
I,
think
it
messed
up
the
the
font
size,
the
console
yeah,
but
if
I
run
math.
A
B
A
To
know
that
you
have
both
options:
okay,
Okay!
So
what
else?
So
we
have
our
short
URL
entity
and
what
I
think
I'm
going
to
do
now
is
I'll,
probably
go
ahead
and
create
this
ash
controller
action
that
we
talked
about
right.
So
we
talked
about
three
different
calyx
components:
one
is
the
short
URL
entity
and
another
one
would
be
an
action
to
sit
in
front
of
this
action
that
can
generate
actually
generate
a
short
URL
and
then
some
action
to
Output
the
events
to
a
Kafka
broker.
A
A
A
A
B
B
A
I'll
we'll
need
to
Define
where
to
hit
this
action,
we'll
eat
this
on
S
endpoint.
We
just
want
to
make
sure
that
we
do
the
what's
as
small
as
possible.
Right
in
any
case
here,
I
don't
have
an
idea
right.
The
ID
will
be
generated
by
this
action
itself,
so
I
will
only
receive
the
original
URL
and
then
I'll
need
to
generate
generated
short
URL.
A
A
A
There
are
several
online
resources
discussing
these
type
of
URL
shortener
service,
and
you
can
go
ahead
and
read
more
about
why
it
is
interesting
to
use
these
md5
plus
the
base62
encoding,
okay,
so
so
yeah
to
do
this
I'll
first,
so
obviously
I
would
need
a
base62
implementation,
I'll
copy
one
that
I
have
here
because
yeah
it's
just
easier
than
to
include
a
new
library,
so
so
yeah.
This
is
an
existing
implementation
of
base62.
I'll,
just
copy
it
and,
and
then
I'll
be
making
use
of
it.
A
B
A
A
A
B
A
A
B
A
And
with
these
component
client,
when
we
need
to
do
a
call
to
another
component,
which
is
the
case
here
right,
we
want
to
call
this
short
URL
entity.
We
can
just
do
something
like
this.
Okay,
it's
an
Event,
Source
entity.
I
want
to
use
here.
I
need
to
provide
here
the
the
ID
of
the
of
for
these
Event
Source
entity
and
then
I
need
to
do
call
and
then
a
lot
of
options
here.
But
I
want
to
call
this
short
URL
entity
create
okay
and.
B
A
B
B
A
B
A
A
Where
calculating
the
ash
for
that
URL
and
then
encoding
it
with
base62
and
taking
the
seven,
the
first
seven
characters
and
then
we're
creating
a
Creator
argument
that
we
are
forwarding
to
our
Event
Source
entity,
and
we
did
this
by
using
our
new
types
client,
which
makes
it
very
easy
and
very
hard
to
make
mistakes
when
passing
in
parameters
and
things
like
that.
Okay,
there
you
go
and
also
where,
before
we're
sending
this
deferred,
call
so
meaning
that
the
reply
from
the
the
entities
what
we
get
as
a
reply
here
as
well.
A
Okay:
let's
try
this
okay,
it
started
without
dishes.
Apparently,
let's
do
a
kernel
so
before
we
tried
creating
these.
These
short
URL
for
Google,
but
now
I'm
using
I'll,
be
using
this
action
instead
of
passing
the
the
short
URL
that
that
I
wanted
to
generate
right,
so
I'll
just
tell
it
I'll
use
the
S,
create
right,
I
won't
pass
any
ID.
I
won't
pass
any
short
idea.
I'll
just
send
the
original
URL,
which
is
actually
called
URL,
is
endpoint.
A
A
A
A
Okay,
so
maybe
it's
time
for
us
to
create
the
the
other
entity.
Sorry,
the
other
action
that
we've
talked
about
right.
So
we
kind
of
covered
the
base
basic
scenarios
where
we
want
to
send
the
URL,
have
it
asht
and
be
able
to
to
be
redirected
to
it.
Now,
let's
do
an
action
that
can
publish
all
these
events
to
the
outside
world
right
too
I,
don't
know
Kafka
to
be
consummed
later
for
data
analysis,
so
I'll
be
creating
a
new
action
or
call
it
URL
to
topic
action.
B
A
A
A
B
B
A
Get
partitioned
as
as
expected
because,
for
instance,
if
you
for
sending
this
to
Kafka,
if
you
don't
make
sure
that
your
metadata
as
the
proper
CS
subject,
then
your
your
messages
for
this
specific
entity
for
one
specific
entity
might
get
out
of
order.
So
so
yeah,
let's
just
first
get
the
the
context
ID
here.
A
B
A
Right
so
now
we,
if
we
want
to
to
test
this,
we
probably
have
two
two
choices
right.
We
could
either
go
to
the
docker
compose
file
and
add
a
new
Kafka
container
and
try
to
test
this
by
ourselves
or
the
other
interesting
option
and
something
that
is
also
something
that
we
introduce
now
is
the
ability
to
test
these
broker
Integrations
on
your
integration
tests.
A
A
A
A
A
A
B
B
B
B
B
A
A
B
A
B
A
A
B
B
A
Yeah,
it
fails
why?
Because
you
see
that
it's
very
similar,
but
you
have
an
extra
plea,
because
here
this
is
because
on
this
reply,
this
comes
with
with
the
with
the
quotes
and
when
you
do
this,
obviously
you
don't
get
the
codes
the
quotes
so
yeah.
The
proper
way
to
solve
this
is
to
have
to
not
use
directly
the
the
string
here
but
to
use
a
proper,
a
proper
type
to
wrap
the
the
content
of
the
reply.
But
for
this
purpose,
I'll
just
I'll
just
do
something
like
this
contains.
B
A
Cool
okay,
so
this
is
the
Eventing
test
kit
or
the
the
mock
test
kit
supports
that
we
introduced
in
this
latest
version
that
allows
you
to
test
these
Integrations
that
you
have
with
Kafka
without
actually
having
a
a
real
Kafka
instances.
Running
I
mean
it
can
still
be
useful,
depending
on
the
use
case
that
you
can
have
a
real
Kafka
instas
and
have
your
integration
tests
running
against
that.
A
But
I
think
in
some
cases
where
you
are
mainly
validating
business
logic,
it
is
much
more
convenient
for
you
to
use
these
test
kit
mock
broker,
because
you
can
just
easily
do
assertions
without
having
to
deal
with
specific
Kafka
clients
and
yeah.
That's
what
would
be
what
we
would
need
to
do
if,
if
we
do
that,
when
we
don't
have
these,
this
MOX
broker
will
need
to
have
a
specific
Kafka
client
and
a
specific
image
running.
A
But
it's
very
convenient
when
we
are
mainly
concerned
about
testing
business
logic,
okay
and
yeah
I
think
we
briefly
saw
that,
but
there's
different
things
that
you
can
do.
You
can
expect
multiple
messages
at
a
time
where
you
can
assert
that
no
message
is
written.
Yeah
different
things,
yes,
so
the
only
other
thing
that
I
think
is
missing
here
is
we
actually
also
want
to.
A
B
A
A
A
A
B
A
A
A
A
B
A
A
A
So
another
interesting
Improvement
that
we
did
is
that
now
you
can
also
see
the
integration
tests
logs
in
in
plain
text
and
the
fact
that
we
now
publish
native
Native
images
from
the
for
Native
PRM
images
for
the
proxy.
Allow
us
to
run
this
integration
tests
must
match
faster
than
before.
So
it's
easier
to
understand
these
problems.
A
A
So
is,
oh
sure,
yeah.
So
this
is
why
right
we
only
declared
that
we
want
to
publish
the.
We
only
have
an
angler
for
the
URL
created.
We
haven't
declared
one
for
the
the
URL
access
and
we
also
said
that
we
want
to
ignore
the
events
that
we
don't
know.
So
if
we
haven't
used
these
five,
we'll
probably
have
some
errors
on
our
logs,
but
since
we
have
that
flag
active.
A
Use
the
heading
yeah:
this
is
interesting
right,
so
here
we
don't,
we
don't
have
on
the
event
itself.
We
don't
have
the
the
ID.
You
see
that
here
on
the
create
command,
we're
using
the
shirt
ID,
but
that
does
not
exist,
but
we
can
still
have
the
the
subject
ID
from
the
action
context,
so
we
can
actually
go
here
and
after
event
subject
and
and
we
can
get
it
from.
B
A
A
This
was
very
interesting
actually
to
show
how
useful
these
these
tests
are
right.
You
we
actually
missed
that.
We
were
missing
this
designer
here
to
actually
publish
this
type
of
events
and
now
yeah.
Now
it's
there
now
it's
passed
foreign
yeah.
So
let
me
check
again
my
notes
and
see
if
there
was
anything
else
that
I
wanted
to
mention:
okay,
okay,
so
I
think
in
terms
of
codes.
This
was
all
that
we
wanted
to
have
right.
So
we
have
just
kind
of
doing
a
recap.
A
We
have
Event
Source
entity
that
are
maybe
better.
Let's
start
with
the
URL
control,
we
have
the
control
that
received
requests
for
creating
the
the
short
URL
and
it
will
generate
an
ash
and
the
base
using
md5
and
then
encode
it
with
base62
and
then
create
this
short
link
and
then
for
the
request
to
The
Entity.
One
thing
that
I
think
probably
would
want
you
could
want
here
was
so
that
the
user
only
eats
these
dots,
slash,
S
endpoints.
We
could
probably
have
something
like
here.
B
A
B
A
B
A
Okay,
we
also
had
some
nice
logs
here
what
else?
What
else?
Let
me
just
check
my
notes
if
I
have
anything
else
that
I
need
to
that
I
wanted
to
share
with
you.
Okay
I
think
that's
it.
So
the
only
thing
that
is
remaining
now
is
to
actually
go
ahead
and
see
how
we
can
use
the
new
calyx
container
register
to
deploy
our
application.
A
What
we'll
do
now
is
actually
try
to
deploy
our
application
to
our
galaxy
slot,
as
I
mentioned,
we'll
go
into
take
advantage
of
the
calyx
container
registry.
To
do
that,
so
I
I
won't
go
into
detail
on
how
to
configure
the
calyx
container
registry,
because
you
can,
you
can
have
that
information
from
from
the
docs.
You
need
to
also
have
a
predefined
calyx
project
created,
so
you
can
do
these
steps
that
I'm
going
to
do
and
be
authenticated
on
the
calyx
CLI,
but
yeah.
All
that
information
is
on
the
documentation.
A
If
you
want
to
have
a
look
so
here,
let
me
just
check
I
have
this
project
defined,
so
you
see
I'm
using
this
organization.
Light
band
and
I
have
end-to-end
testing
apps
name,
so
what
I'll
do
now
is
I'll,
go
ahead
and
change
my
repository,
and
so
here
is
where
I'll
say
that
I
want
to
use
the
calyx
container.
A
B
A
So
one
of
the
interesting
things
with
with
the
calyx
a
container
register
is
that
you
can
actually
actually
share
images
across
different
projects.
So
in
this
case,
I'm
actually
uploading
I'll
be
uploading.
The
image
for
this
specifically
project,
but
if
I
remove,
if
I,
would
want
to
share
this
image
across
all
the
organization,
I
could
do
do
it
like
this
okay.
A
A
B
A
A
B
B
B
A
A
A
A
A
A
A
A
So
then
we'll
be
able
to
do
the
the
request
and
use
the
URL
shortener.
Hopefully,
if
I'm
not
missing
something
else,
but
you
can
see
how
this
the
fact
that
I'm
able
to
use
the
in
the
calyx
container
registry
makes
me
able
to
do
these
iterations
very
quickly.
Right
I
can
just
modify
something
upload.
A
new
image
and
yeah
see
how
it
goes.
A
A
A
A
You
can
can
run,
use
the
calyx
rental
and
run
both
the
docker
compose
file
and
your
Helix
proxy,
but
you
can
also
do
calyx
run
and
just
make
sure
you
start
the
docker
compose
on
the
side
and
we've
also
see
now
how
useful
the
types
client
can
be
for
doing.
Cross-Component
calls
and
the
fact
that
you
know
automatically
what
are
the
types
of
parameters
that
you
have
to
pass.
A
This
is
something
that
was
a
little
bit
different
on
the
previous
version
where,
with
the
web
client,
where
you
get
to
to
guess
kind
of
guess
the
types
because
you
need
to
place
the
the
parameters
on
the
URL
and
things
like
that.
We've
also
looked
at
the
test.
Kit
mocks
broke
right
and
the
ability
to
test
your
Integrations
with
a
broker
without
actually
having
a
real
broker
running.
A
That
is
very
useful
when
testing
your
business
logic
and
finally,
we
also
experimented
with
the
Galaxy
container
registry
that
allows
you
to
upload,
build
the
package
and
upload
your
images
very
fast
to
the
calyx
container
registry,
with
authentication
already
built
in
with
with
calix.
So
you
don't
have
to
worry
about
having
a
third
party
or
relying
on
a
third-party
registry
to
to
all
your
images.
A
So
this
is
a
I
think
these
are
very
nice
improvements
that
allow
you
to
iterate
faster
on
that
on
that
cycle
of
software
development
and
and
bring
your
services
and
your
applications
up
to
calix
much
more
rapidly
yeah.
But
we're
not
finished.
Obviously,
there's
a
lot
of
more
stuff
coming
up
so
make
sure
you
keep
following
us
and
and
follow
the
blog
and
follow
the
webinars
to
to
be
always
up
to
date
of
of
the
latest
things
that
that
are
coming
out.
A
If
you
want
to
have
a
look
at
the
project
sample,
it
will
be
up
on
my
on
my
GitHub
account
and
here's.
The
link
yeah
I
think
that
that
is
all
from
my
side.
Thank
you
very
much
for
attending
this
webinar
and
if
you
have
any
follow-up
questions,
anything
feel
free
to
use
our
dedicated
slack
channel
that
yeah
it
exists.
Just
for
that.
So
thank
you
very
much
again
see
you
around.
Thank
you.