►
From YouTube: Kyma Community Meetup 01.07.2020
Description
This virtual event is designed for end users, a space for our community to meet, get to know each other, and learn more about Kyma. We plan to have at least one demo in every meeting, with allocated time to discuss this in small groups.
Agenda:
🌱 Kyma Serverless operating on bare metal k8s resources - why and what are the implications for your lambda functions? (Krzysztof Kwiatosz, Mateusz Puczyński) - 1:25
🌱 Prototyping “GitOps” in serverless - give us early feedback so that we can boost devX. (Krzysztof Kwiatosz, Marcin Witalis) - 24:10
Get the meeting agenda to find out what topics are planned for the meeting.
https://docs.google.com/document/d/1vWleTon7sJIk0teee4SoVezS4mR3K8TlkvXkgLJwRD8
Find out more about our meetup at : https://kyma-project.io/community/collaboration/#kyma-community-meetup-kyma-community-meetup
A
A
A
We
allow
a
little
bit
more
time,
I
think
there
are
quite
complex,
and
hopefully
maybe
we
can
have
some
discussions
around
those
topics
and
then,
if
there
are
any
other
topics
at
towards
the
end,
we
can
think
we
can
squeeze
them
up.
So
the
main-
let's
not
talk
too
much
about
it,
the
main
person
who
will
present
today
Christoph,
we
will
talk
about
several
a
schema
service
or
the
new
I'd,
say
approach
that
we
have
we
took
and
then
we
will
have
a
prototype,
basically
using
ETOPS
in
servlets.
So
both
are
so.
B
B
B
Flexible
and
in
the
function
controller
is
the
holds
the
definition
of
what
code
snippet.
What
what
code
should
be
should
be
run
as
a
function.
Then
they
did
this.
This
code
is
being
built,
and
then
we
we
used
a
native
service
to
to
actually
run
the
deployment
run
the
code
and,
as
you
can
see,
the
key
native
servants
has
its
own
type,
K
native
service
and
the
controller
for
that
type
has
a
lot
of
functionalities
like
revisions
of
of
K
service.
B
It
has
some
complex
routing
policies
to
determine
which
actually,
revision
should
be
should
be
hit
and
it
was
working.
If
it's,
it
was
a
it's
still
working
right
in
NP,
my
1.13
and,
however,
we
decided
to
give
it
a
try
with
bare
metal,
kubernetes
components
to
that
end
and
I
will
switch
to
this
architecture.
Diagram
that
is
coming
from
master
branch,
where
you.
B
Is
already
merged?
Yes,
that's
already
Merton
master,
however,
it's
not
yet
released,
it
will
be
in
the
next
Kimmel
release
and
I
will
talk
about
later
on
what
what
could
be
the
implications
for
your
own
functions.
But
let's
focus
on
this
on
this
diagram
and
you
you
won't
see
any
Kennedy
components.
It's
much
simpler.
We
don't
use
the
versions
of
service.
It's.
It's
really
really
simple
that
we
simply
and
the
function
controller
creates
a
deployment.
B
B
Now,
let's,
let's
think
about
why
why
we
did
that
and
there
was
an
issue
created
in
a
github
to
let's
say
to
prove
the
to
document,
the
argumentation
for
that
and
to
also
trigger
a
discussion
about
that.
Let's
not
read
it,
but
let's
just
talk
about
the
bullet
points.
While
we
did
that
and,
as
you
know,
you're
not
developing
it
for
ourselves,
we
have
some
users
right
and
recently
we
have
defined
personas
and
one
of
the
persona
is
Matthew.
B
Who
is
a
cloud
native
software
engineer
and
during
the
workshops
we
realized
that
all
he
needs
a
thin
thin
multi-cloud
runtime
and
what
we
have
learned
trying
out
like
a
native
serving
for
the
purpose
of
service,
is
that
it's
not
necessarily
thin
and
it's
it's
it's
complex
and
complex
and
I
know
that
we
we
assume
that
Matthew
he's
an
experienced
cloud
native
engineer.
He
is
a
lot
of
knowledge
about
CN
CF
landscape,
but
maybe
for
somebody
who
is
less
experienced
in
the
CN
CF
landscape.
B
It's
it's
hard
to
comprehend,
really
all
the
all
the
possible
modules
and
dependencies
that
are
you,
and
it's
really
important
for
him
to
learn
how
things
work
internally.
So
the
simpler
solution,
the
better
and
the
more
lightweight
solution,
the
better,
because
he
probably
doesn't
want
to
pay
a
lot
of
money
and
for
us
very
simple
function,
because
we
are
focusing
on
simplicity,
in
surveillance
and
and
and
such
that,
what
we
need,
and
with
fee
with
the
deployment
service,
horizontal,
put
auto
scaling.
We
can,
we
did
a
POC
and
it
proves
that
it
really
really
works.
B
So
it's
what
we,
what
we
gained
is
our
actually
simplicity.
It
will
be
simple
to
maintain
and
simpler
for
Matthew
to
comprehend,
really
how
it
works
and,
and
as
we
know,
the
key
native
is
a
is
a
big
product.
Is
it's
it's
a
project
right?
He
says
its
whole
programming
model
and
it
comes
with
a
lot
of
features
and
we
actually
didn't
use
those
features
for
kima
serverless
and,
for
example,
this
versioning
of
of
k,
services.
B
The
serve
k
native
serving
was
revisions
were
not
the
ones
that
are
actually
keeping
track
of
revisions
of
Masius
code.
So
it's
not
not
really
this
this
use
case.
What
we
need.
We
actually
needs
need
revisions
on
this
level
on
function,
control
level,
and
this
is
what
we
will
try
to
achieve
with
with
key
tops
and
with
the
topic
that
I
will
present
you
later
on.
B
Yeah
and
as
you
can
see,
as
you
could
see
in
the
diagram,
it
was
built
with
the
with
the
kubernetes
component,
so
the
building
blocks
to
really
achieve
a
server
assertion
are
available
already
on
kubernetes
and
what
we
also
gained
is
more
freedom
to
upgrade
governance
and
easter
version,
and
can
it,
if
also
has
some
dependencies
for
for
Easter
and
kubernetes
version.
So
and
if
we
don't,
you
know,
use
it
in
in
service
module
and
we
have
more
freedom
to
upgrade
a
kubernetes
and
history
of
versions
and
when,
when
will
it
happen?
B
B
It
will
be
a
little
part
of
the
next
cameras
and
it's
probably
the
most
interesting
for
you
to
learn
about
what
would
be
the
implications
for
you
and
a
native
serving
has
a
capability
to
scale
the
deployments
to
zero.
If
we,
if
we
have
stripped
that
and
we
don't
use
native
serving,
then
we
don't
have
scale
to
zero
out
of
the
box.
So
we
want
to
fill
that
gap
and
there
is
an
investigation
already
ongoing,
which
of
the
available
autoscaler
for
kubernetes
will
fit
the
need.
B
How
does,
how
to
scale
his
works
that
are
available,
which
metrics
they
take
into
account
and
that
will
be
then
later
evaluated
and
and
the
auto
scaling
will
be
will
be
done
if
this
support
scale
to
zero,
we
really
need
to
collect
all
the
requirements
in
order
to
to
pick
one,
because
I
understand
that,
for
some
users
who
want
to
who
want
to
use
server
less,
there
might
be,
and
different
metrics
could
be
important
right
based
out
of
scaling
strategies.
So
we
need
to
understand
the
needs
for
some
schedule.
B
0
might
be
an
absolutely
must-have
for
some.
It's
not
really
necessary,
so
need
to
understand
the
needs.
And
yes,
we
already
have
some
solutions
in
mind.
For
example,
I
mean
I
was
mentioning
cada
Aneesh
was
proposing
was
we
are
investigating
and
evaluating
options,
but
the
really
requirements.
So
what
really
Matthew
needs
is
the
key
indicator
here.
So
if
you
have
some
really
really
must-have
requirements
for
auto
scaling
capability
for
service,
then
please
contribute
to
this
issue.
B
And
emigration,
so
what
will
happen
with
the
if
you
upgrade
FEMA
1.14
to
a
newer
version?
Lively,
the
migration
is
fully
automated.
There
is
an
upgrade
job
running
automatically
and
there
you
don't
need
to
do
any
manual
steps
to
make
sure
that
the
functions
that
you
defined,
four
four
four
previous
versions
of
kima,
will
still
work
on
the
thin
and
lightweight
version
that
will
come
with
the
next
release
and
now
I
would
like
to
open
here
for
questions,
because
you
probably
have
some.
A
B
The
moment,
the
only
thing
that
could
be
missing
is
the
scale
to
zero,
but
as
far
as
I
know
and
well
it's
it's
all
about
probably
the
operational
costs
and
there's
one
thing
that
you
could
have
a
cheap
solution
by
adding
by
having
schedule
0,
but
also
you
could
have
a
cheap
solution,
something
that
is
not
eating
up
too
much
money
on
your
hyper
scalers.
It's
also
something
that
is
simpler
and
lighter,
doesn't
include
and
big
sidecars
to
the
functions.
So
it's
it's.
It's
a
balance
that
we'll
need
to
find.
B
Actually
here
we
still,
we
would
like
to
investigate
how
to
scalars
that
would
allow
scale
to
zero
because
it
might
be,
it
might
be
an
important
use
case
for
for
some
of
the
users
right
at
the
moment.
It's
it's
not
there
and
it's
like
we
stripped
all
the
features
that
were
not
used
by
us
and
gained
a
lot
of
simplicity
in
the
whole
architecture.
B
And
now
it's
like
a
like
a
canvas
where
we
can
paint
some
new
features
and,
for
example,
invest
in
the
different,
auto
scaling
mechanism
done
that
the
one
that
was
out
of
the
box
available
via
a
Kenichi
serving
we
could
think
about
what
the
the
CN
CF
developer
wants.
How
he
wants
to
write
functions,
whether
we
should
maybe
support
it.
A
The
nebulous
for
for
future,
basically
easy,
updates
or,
let's
say,
feature
that
we
want,
because
we
are
not
so
tightly
coupled
with
the
and
basically
the
the
power
or
the
little
resources
that
we
are
saving
by
by
reducing
some
of
the
components
that
are
needed
in
a
way
kind
of
balance.
Out
with
with
the
second.
A
A
Think
most
of
the
people
in
the
team,
most
of
people
in
the
color,
basically
from
the
team
I'm
trying
to
figure
out
if
somebody
from
outside,
but
most
of
us,
we
are
up
to
date
with
the
widows
with
this
process
because
was
was
reviewed
and
also
we
were
following
the
issue
there,
but
would
you
I
will
ask
another
question:
maybe
in
the
name
of
the
people
that
they
try
to,
you
know
they
will
upgrade
in
soon
and
they
will
ask
him
what
will
be
the
change
for
me.
You
mentioned
that
this
will
be
automated
migrate.
A
B
C
A
A
D
D
C
A
C
It's
a
little
orchid
anything
and
we
cannot
get
rid
of
it.
I
mean
we
need
to
use
it.
So
that's
one
of
the
reason
that
can
you
deserving
charts
are
still
part
of
the
source
code.
Okay
and
the
functions
are
more
lightweight
because
they
are
not
anything
that
much
of
resources
when
they
create
the
functional
we've.
Just
a
few
simple
resources,
not
that
plenty.
A
C
But
it
was
not
at
the
part
of
immigration
because
we,
it
was
already
on
kubernetes
jobs
and
the
built-in
depends
highly
on
the
resources
available
but
after
but
builds
take
said
no
less
than
20
seconds.
So
this
quite
fast,
let's
say-
and
this
only
made
it
worse
when
you
create
or
update
the
function
resource
is
not
created
every
time
when
a
functioning
scale
up
on
the
screen
down.
So
then
it
is
much
faster
because
we
just
scaled
the
deployment
we
had
supports
on
something
like
that.
We
don't
create
any
new
deployments.
A
So
for
the
developer,
that's
let's
say
probably
the
I,
don't
know
how
many
they
use
the
interface,
the
web
interface
to
write
their
functions.
Probably
the
next.
The
next
talk
Christophe,
you
propose
something
propose
something
new,
but
if
I
would
use
the
interface
would
I
see
an
improved
in
in
speed
of
reaction
or
would
be
kind
of
the
same
as
the
previous
version.
It.
C
Would
be
much
faster
set
when
you
create
the
big
face
was
not
touch,
but
this.
Let's
say
this
setting
part
will
start
and
right
now
we
create
only
few
pure
simple
resources.
We
don't
wait
for
other
resources
as
opposed
of
Kennedy
serving
so
that
part
will
be
much
faster
than
before
so
I
know,
I,
don't
remember
exactly
how
long
it
took
okay,
it
is
serving,
but
currently
it
is
less
because
we
create
less
resources
in
the
cluster
and
we
don't
need
to
wait
for
site
class
and
other
parts.
I.
C
Not
exactly
because,
most
of
the
part
that
consumers
most
resources,
it
was
the
beat
face,
and
if
the
job
requires
little
trucko
and
memoria,
but
I
think
the
future
will
be.
Every
I
will
be
able
to
configure
as
much
resources
requirements
and
minutes
per
function
for
built.
So
you
will
be
able
to
less
resources
to
function.
Then
the
bill,
do
we
take
longer
I
do
smaller
machines,
so
it
would
depends
on
your
configuration
right
now
it's
configured
to
doing
cream
installation,
but
the
affinities
needs
to
be
exposed
to
the
user.
Okay,.
B
C
The
problem
with
building
part
is
also
that
it
uses
docker
or
clients
to
build
images
which
it
in
itself
needs
some
kind
of
minimal
resources.
So
the
resources
that
we
are
using
right
now
are
comparably
low
to
what
probably
some
kind
of
big
Java
monolith
application
would
need.
So
I
would
expect
in
the
future,
though,
to
increase
the
resources,
then
to
lower
it,
because
if
we
lower
it,
then
the
you
time
increases
significantly.
A
Which
is
taking
the
time
I
think
we
are
quite
okay
with
this
one.
We
we
have
another
part
Christophe
right
regarding
the
get
ups.
Maybe
you
can
pick
that
up
and
then,
if
there
are
questions,
they're
somehow
related
right
and
then,
if
there's
questions,
we
can
pick
them
out
towards
the
end.
Absolutely
so.
Okay.
B
B
So
something
like
that
and
that's
not
super
convenient
for
a
developer
right
and
this.
That
was
the
assumption.
Maybe
yeah,
maybe
you
can
you
can
say
that?
Would
you
yeah
would
you
would
you
would
like
to
continue
writing
the
source
code
here
in
the
web?
Id-
probably
not
right,
because
all
the
developers
have
their
own
favorite
IDs
and
so
does
our
Matthew.
B
Ops
approach
for
for
the
user
to
define
lambda
functions
so
he'll
be
able
to
really
coat
and
hack
his
his
lambda,
his
blue
coat
and
then
push
it
to
get.
And
now
what
needs
to
be
done
for
our
server
has
to
pick
it
up
and
serve
it.
Then
we
have
started
the
POC,
and
here
is
the
issue
which
will
be
also
great
now,
to
confront
and
to
validate
the
requirements
before
we
jump
into
any
technicalities
and
then
the
API.
B
But
still
if
somebody
is
using
keema
for
hackathons
and
want
to
really
hack
a
simple
lambda
just
for
now
not
necessarily
to
keep
the
revisions
and
to
keep
to
keep
it
for
later,
then
we
can
preserve
the
possibility
to
use
the
web
UI.
The
function
could
be
fixed
to
a
specific
branch
and
optionally
to
a
commit.
If
that
we
rather
fixed
one,
but
in
case
the
commit
hash
is
not
fixed
and
the
function
is
being
rebuilt.
Every
time
there
is
a
new
commit
to
the
branch
we
would
like
to
support
the
private
repository.
B
B
A
Maybe
just
let
me
pick
it
up
for
people
that
might
see
it
on
YouTube
or
or
you
know,
jump
in
later.
This
is
this
is
a
POC.
This
is
a
proposal.
This
is
an
exploration.
What
we
do
now
is
we
ask
the
question:
what
if
we
would
use
git,
ops
and
those
are
some
of
the
requirements
that
we
came
up
to?
Obviously
this
is
a
issue
it's
open
and
anyone
can
contribute.
So
this
by
far
is
not
ready.
B
E
E
So
we
have
multiple
interfaces
and
actually
our
operator
is
controller.
It's
working,
its
operating
system
and
functions
are
created
for
specific
namespaces.
This
is
just
for
this
is
not
only
for
convenience,
so
so
users
can
have
the
decadence
basis,
but
also
it's
for
a
security
reason,
and
actually
what
we
learned
is
like.
We
need
to
have
all
those
objects
that
are
responsible
or
that
math
you
need
to
have
for
the
particular
namespace
for
function.
In
this
new
phase,
I
mean
both
functions
here,
D
and
purpose
Doris
Eid
should
be
here
with
credentials.
E
Right
second
thing
is
that
the
function
control
is
actually
doing
exactly
the
same.
What
math
you
could
manually
do
it's
just
like
doing
it
for
him
and
the
function,
controller,
checks
for
for
changes
in
each
reconcile
cycle
and
and
actually,
if
there
is
a
difference
between
the
state,
desired
state
and
the
current
state.
It
applies.
Those
changes
to
function,
a
controller
we
also
prepared,
actually
one
I,
think-
is
a
user.
Also,
of
course
it's
interacting
with
get
from
from
the
outside.
So
it's
not
a
part
of
any
proprietary
whatever
he
just
simply
come.
E
It's
tough
and
it's
actually
visible
for
a
controller.
This
is
the
proposal
for
API.
We
thought
that
Seska
tops
itself,
it's
a
white
topic
and
actually
it's
a
thing
that
can
be
adapted
in
multiple
places
in
keema,
devised
to
to
lift
to
add
the
33444
for
this
forever
story
for
entire
,,
because
this
way
everybody
will
be
lifting
from
this
right.
The
changes
in
the
function.
Custom
resource
itself
are
backwards
compatible.
That
means
that
we
can
have
previous
functions
working
exactly
the
same
as
they
were.
However,
there
are
a
couple
of
changes
we
added.
E
Voice
that
the
sources
are
stored
into
to
meet
the
requirement
for
multiple
functions
which
are
seeking
the
same
repository,
we
had
that
it's
this
base
directory,
which
is
showing
exact
path
to
the
to
the
function
sources
we,
yes,
we
didn't
want
to
have
any
limitation
as
it
comes
to
forcing
user
to
have
some
layout
of
the
story.
That's
why
we
also
asking
to
provide
a
docker
file,
which
is
in
context
of
this
repository,
of
course,
and
the
comet
and
the
branch.
E
E
B
Is
the
idea
how
we
will
try
to
model
it
to
point
the
source
for
a
function?
Hopefully,
hopefully
we
could.
We
could
show
something
running
on
the
next
Meetup
at
the
moment,
yeah.
It's
like
a
sanity
check
of
the
community.
If,
if
the
API
looks
good,
if
the
concepts
look
good,
so
your
feedback
is
is
really
more
than
welcome
here.
E
E
B
To
answer
the
question:
if
we're
the
first
do
that,
of
course
not
I
mean
there's,
of
course,
something
called
like
cloud
functions
in
Google
cloud
which
allows
you
to
to
provide
the
code
in
an
inline
editor,
but
you
can
also
point
to
a
cloud
to
a
repository
to
you
know
to
select
the
the
branch
yeah
the
tag,
the
directory
within
the
source.
So
it's
well,
it's
it's
a
similar
to
Zuma.
Of
course
we
cannot
yeah.
A
E
Is
actually
the
the
flow
of
sidon
Universal
flow
of
the
of
the
kiddos
right?
So
you
have
some
code,
you
have
some
some
repository,
which
is
like
somewhere
unit
tests
and
integrations
are
in
the
pipeline
of
CICS
D,
right
and
Bute
and
deploy
it's
us.
So
this
is
like
kind
of
we
just
push
the
code
to
the
repo.
Your
CI
is
doing
the
unit
test,
it's
built
in
our
income,
and
actually
this
is
pretty
pretty
much
the
default.
E
A
E
Maybe
I
also
share
reviewed
how
how
them
that
the
current
customer
resource
definition
looks
like,
and
actually,
if
you
want
to
make
a
function,
you
need
to
specify
a
source
code
and
dependencies,
and
this
is
how
the
the
function
is.
Is
that
introduced
to
to
refer
to
infrastructure,
and
this
will
give
us
much
much
more
flexibility
because
we
can
come
up
with
different
types
of
and
just
like
you
know,
we
are
open
for
for
for
for
extending
this.
This
idea.
A
Well,
I
mean
if
they're
not
I,
think
we
could
do
definitely
love
to
see
a
you
know
more,
like
a
working
demo
very
soon
to
see
what
you
know,
how
does
it
feel
for
a
development
and
I?
Don't
have
a
question
regarding
that?
What
are
the
main
challenges
that
you
guys
are?
You
know
still
trying
to
check
and
overcome
with
this
POC,
and
maybe
you
know
with
this
opportunity
trying
to
reach
out
to
other
people
that
would
like
to
contribute
and
help
out.
E
Now
we
are
in
the
in
the
in
the
integration
phase,
so
we
are
just
checking
or
connecting
everything
together
and
actually
there
were
no
kind
of
big
problems
that
we've
encountered.
This
is
like,
as
this
actual
architecture.
It's
not
it's.
The
simplest
I
believe
approach
that
we
could
take
to
to
meet
all
the
requirements.
So
so
we
try
to
try
to
try
to
do
it
as
simple
as
possible
to
try
not
to
be
to
be
to
be
able
to
do
it
in
and
in
some
period
of
time,
actually
right
now,
it's
actually.
E
B
For
me,
the
biggest
challenge
is
still
to
really
define
the
requirement
I
mean
in
in
this
in
this
POC
and
we
are
giving
the
user
full
control.
This
is
more
like
here's,
the
code
and
please
build
it
and
run
it
according
to
my
doctor
file
all
right.
This
is
what
we
are
giving
him
the
possibilities
right-
and
this
is
probably
suitable
for
for
Matthew,
who
is
a
very
experienced
CNC
after
Gerber
and
he's
very
fluent
with
talker
etc.
B
For
me,
the
question
here
is
also:
if
we,
if
we
could
also
sub,
add
some
convenience
to
it,
so
something
like
here's,
the
code,
it's
in
nodejs,
just
run
it
I,
don't
care
how?
So
if
we
should
have
some
built-in
convenience
like
a
built
box
or
preset
docker
files,
that's
that's
something
that
we
still
need
to
investigate.
B
If
you
have
an
input,
an
insight
on
this
one
that
would
be
also
really
appreciated,
because
we
might
target
not
only
those
super
experienced
CN
CF
developers,
but
there
might
be
some
business
application
developers
right
who
are
maybe
yeah
like
I
said
just
this
is
the
code.
It's
in
JavaScript,
it's
an
odious
I'm,
not
sure
how
it
should
be
run
just
just
run.
It.
A
A
E
This
is
the
requirement
was
that
he
to
have
multiple
functions
inside
one
report
and
to
not
limit
the
functions
only
for
one
repo,
so
it's
like
you
can
have
both
a
couple
of
functions
in
one
repo
and
others,
just
like
we've
dedicated
repositories,
for
example,
so
it's
like
pretty
flexible
as
it
comes
to
how
you
are
going
to
store
it
right.
You
didn't
want
to
have
any
any.
E
A
So
in
this
way,
for
example,
it
would
have
if
I
would
have
a
more
complex
application
and
I
have
couple
of
hunt,
lambdas
and
but
then
I
would
like
to
roll
back
to
a
different
state.
Then
it
would
be
advisable
to
be
in
one
repo,
because
then
you
can
point
to
a
commitment.
Then
you
can
roll
back
the
entire.
That's
called
application
based
on
multiple.
You
know
London,
but
if
I
would
have
it
distributed,
then
it
would
be
harder
to
have
a
state.
You
know
to
roll
back.
E
This
is,
this
is
like
kind
of
maybe
dude.
We
also
good
to
know
what
is
the
common
use
case,
I
mean,
which
is
there
if
it's
like
one
repo,
mostly
or
it's
like
multiple
repos
that
fee,
but
would
be
good
because
we
could
I
believe
think
of
the
way
how
we
could
improve
it,
but
if
I
believe
the
solution
which
is
presented
right
now,
it's
a
open
enough
to
to
be
good
enough.
In
most
cases,
I
mean
it's,
you
always
have
kind
of
some
corner
cases,
but
I
believe
this.
E
The
lump
mm
is
a
kind
of
a
natural
place
to
test
this
I
mean
it's
a
disappear.
The
key
tops
all
right.
It's
a
it's
a
great
place
to
start
with,
because
it's
a
it's
like
people
who
are
using
it.
It's
like
they,
they
kind
of
think
that
they
by
default,
should
have
it
I,
I,
think
I,
think
but
I
believe
we
can
expand
it
and
we
can
we
can.
This
is
actually
not
my
image,
but
I
could
imagine
that
there
is
a
place
for
for
for
this
approach
in
also
more.
B
This
this,
it
is
housed
in
C
if
the
player
wants
to
write
functions
and
my
craft
services,
so
I
agree
with
you
that
we
it's
like
a
sandbox
and
it's
like
a
playground
for
for
this
function.
Use
case
I
will
be.
If
it
will
be
successful,
then
we
will
probably
aim
to
to
give
more
get
ops
like
developer
development
experience
across
kheema
I.
E
D
For
micro
services,
as
well
as
samplers
and
looking
at
their
so
it
looks,
you
know
the
model.
Is
there
where
you
could
see
as
well
as
a
function
controller,
something
like
a
micro
services,
controller
that
created
the
deployment
and
the
service
and
the
pod
for
you,
based
on
your
code
in
gear,
if
you
supplied
it
aqua
file.
E
E
We
definitely
need
to
have
a
hands
on
experience
for
for
this,
because
I
believe
that
this
is
like
pretty
beneficial.
If
we
we
do
this
in
the
smaller
scope,
we
will
benefit
from
having
and
checking
all
the
problems,
and
since
we
will
have
more
knowledge
about
about
this
right,
we
will
we're
aware
actually
to
industry.
If
you
want
to
expand
this
will
already
in
order
to
at
least
some
problems.
A
A
A
You
cool
well,
then
I
think
we
can
then
wrap
it
up
really
nice
presentation
and
then
very
excited
about
these
get-ups
I
think
we
have
some
interesting
feedback
from
the
audience.
Also
regarding
maybe
having
a
unified
way
of
deploying
this
I
think
it
approach.
Is
it's
it's
a
very
easy
to
understand,
flow
and
I'm
quite
curious
to
see
how
this
ends
up
in
in
kheema.
A
A
A
B
A
A
Well,
thank
you
very
much,
then.
Thank
you
very
much
for
the
presentation
agenda
is
going
to
be
open.
So
please
add
anything
that
you
would
like
to
talk.
It's
very
possible.
The
next
week
we
will
have
a
presentation
from
from
outside
or
for
the
team.
So
let's
see
how
that
works
out,
but
if
there
are
any
other
topics,
please
add
them
after
to
the
agenda
and
with
each
other
in
two
weeks,
then
thank
you
very
much.
Bye,
bye.