►
From YouTube: Building a FaaS Platform Using CNCF OSS Projects (Knative, Crossplane, Tekton... Mauricio Salatino
Description
Don't miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe in Amsterdam, The Netherlands from 18 - 21 April, 2023. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Building a FaaS Platform Using CNCF OSS Projects (Knative, Crossplane, Tekton, ArgoCD) - Mauricio Salatino, VMware
Functions-as-a-Service platforms have proven to speed development productivity and reduce infrastructure costs when running on public clouds. But installing and managing the infrastructure needed to build your custom Functions-as-a-Service platform on top of Kubernetes requires a lot of work and a deep understanding of how to wire different CNCF projects together to provide a good developer experience. During this presentation, Viktor and Mauricio will demonstrate the use of tools like Crossplane, Knative Functions, Tekton, and ArgoCD to build a self-service FaaS platform. In this presentation, you will learn: Why knowing how to build these platforms is important The different personas involved in these platforms and how to make sure that they all have optimized experiences How to wire different tools together to build a cohesive platform Which APIs are involved in such platforms The live demo presented in this session will also be shared as a step-by-step tutorial for the audience to reproduce in their environments.
A
My
name
is
Mauricio
salatino
I
am
presenting
about
building
functions
as
service
platforms
on
top
of
kubernetes,
but
the
presentation
on
the
topics
actually
apply
to
any
kind
of
platform
that
you
want
to
build
on
top
of
kubernetes.
So
let's
get
started
with
again.
As
I
mentioned,
my
name
is
Marissa
salatino
I'm
at
salawo,
in
Twitter,
and
also
in
in
masterton
nowadays
I'm
working
full
time
on
a
project
that
is
called
K
native
I.
A
So
why
do
you
need
to
build
platforms
on
top
of
kubernetes
or
the
main
reasons
why
I
see
companies
medium
and
large
companies
building
platforms
on
top
of
kubernetes
and
I'm,
pretty
happy
to
say
that
when
I
arrived
here
this
morning,
I
just
actually
go
and
talk
to
a
company
that
is
building
this
kind
of
thing.
So
it's
it's
a
good
validation
for
for
this
presentation.
You
can
go
and
talk
to
local
people
about
these
topics
as
well.
A
So
the
main
reason
to
think
about
building
platforms,
type
of
kubernetes
is
because
kubernetes
actually
provides
you
only
a
set
of
building
blocks
that
you
need
to
use
to
create
more
complex
tools
for
actually
deploying
your
workloads
right,
like
kubernetes,
provides
you
Services
deployments,
increases
and
all
these
things,
but
when
you
start
deploying
real-life
workloads
that
are
complex,
you
need
to
combine
them.
Extend
kubernetes
create
your
own
higher
level,
abstraction
layers
to
make
your
life
easier
because
dealing
with
those
low
level
Concepts,
it's
complicated.
The
main
reason
why
we
have
so
many
cncf
projects.
A
They
are
all
great,
because
if
they
are
solving
specific
problems
on
top
of
kubernetes
by
using
all
these
Concepts
and
solving
more
specific
problems,
so
the
moment
that
you
start
using
kubernetes,
you
need
to
start
not
only
learning
kubernetes,
but
you
also
need
to
learn
about
all
the
ecosystem
and
which
tools
are
solving
each
specific
problems,
and
that
takes
time
right.
The
more
larger
the
company
is,
the
more
that
you
see
that
one
single
kubernetes
cluster
will
not
cut
it
right.
Like
the
previous
presentation
about
hypershift
actually
is
going
into
that
direction.
A
You
will
need
multiple
clusters
and
then
you
need
to
manage
the
complexity
of
having
multiple
clusters
right
and
learning.
Kubernetes
is
hard.
I've
seen
this
I've
been
doing.
Kubernetes
trainings
for
some
time
and
I
see
a
lot
of
large
companies
that
the
the
thing
that
they
struggle
the
most
is
basically
bringing
everyone
up
to
speed
into
kubernetes
and
understanding
how
kubernetes
works.
A
So
a
platform
can
help
in
in
solving
some
of
these
problems
right,
like
reducing
the
cognitive
load
of
teams
that
are
consuming
kubernetes
related
tools,
we
can
create
a
platforms
that
basically
provide
a
self-service
approach
to
consume
all
these
complexing
infrastructure
and
tools,
and
we
can
also
improve
our
software
delivery
practices,
but
by
providing
a
platform
that
basically
curate
all
best
practices
about.
How
do
we?
How
teams
should
deliver
software
to
different
environments?
A
So
I've
included
here
kind
of
like
one
of
my
definition
of
what
the
platform
is
and
for
me
nowadays
in
2022,
because
this
is
actually
changing
a
lot
in
the
kubernetes
space.
A
platform
is
just
a
collection
of
services
and
tools
focused
on
enabling
teams,
with
the
self-service
approach
to
get
the
tools
that
they
need
when
they
need
them
right.
So
we
are
going
to
be
seeing
now
in
a
couple
of
demos.
A
How
kind
of
like
we
implement
this
with
open
source
tools
and
how
the
platform
experience
should
look
like
in
reality
when
you
start
looking
at
things
and
and
the
shape
of
these
tools?
And
how
do
you
combine
different
tools
to
create
one
of
these
platforms
that
I'm
talking
about?
You
will
see
that
it
looks
something
like
this.
A
You
have
a
bunch
of
teams
that
wants
to
consume
and
interact
with
complex
infrastructure
and
tools,
and
for
that
you
have
a
team
building,
something
that
we
are
calling
a
platform
in
this
diagram
that
basically
expose
the
platform
API.
These
teams
that
wants
to
consume
all
this
tooling.
On
the
on
the
right
hand,
side.
They
only
need
to
understand
how
to
interact
with
that
API.
A
So
if
you
have
been
looking
into
the
platform
space
in
in
kubernetes
and
I've,
seen
this
kind
of
like
a
lot
in
the
last
cubecon
in
Detroit
and
also
in
Valencia,
there
is
a
book
that
is
being
quoted
quite
regularly,
because
this
talks
about
the
cultural
change
that
you
need
to
apply
in
your
organization.
In
order
to
start
thinking
about
building
platforms.
A
A
So
I
will
start
with
a
very,
very
quick
demo
of
an
application
that
I
built
to
exemplify
the
use
of
this
platform,
and
this
demo
is
this
very,
very
simple
application.
So
this
application,
you
can
actually
access
to
that
instance
of
the
application
here.
If
you
can
scan
that
QR
code,
you
don't
you
don't
need
to
right
like
this
is
just
a
very
simple
demo,
but
it's
live
and
it's
running
in
a
in
a
kubernetes
cluster
that
is
hosted
inside
Google
Cloud
right.
A
So
this
application-
okay,
hopefully
some
people
access
it.
This
application
allows
you
to
very
very
simply.
You
can
generate
a
value
here
on
the
client
side
and
I
can
store
that
value.
That
value
should
be
stored
into
a
radius
database,
which
is,
of
course,
it's
a
live
demo,
so
why
it
should
work,
maybe
internet
connectivity
or
something.
Let
me
refresh
and
see
if
it's
actually
running.
A
I
wonder
if
it's
working
for
some
of
you
folks,
oh
there
you
go
I,
can
see.
I
can
see
the
application
back
in
there.
Let's
see,
maybe
too
many
people
accessing
at
the
same
time
it's
actually
making
any
crash.
It
should
have
like.
You
know
some
some
some
replicas,
but
you
know
it's
running
in
a
different
continent.
Maybe
so
maybe
it's
too
far
away
and
I
can
see
there
you
go.
You
have
all
those
numbers
that
people
is
generating.
A
Of
course
you
can
make
it
crash,
of
course,
but
that's
kind
of
like
the
application
and
the
idea
of
the
application.
Please
do
not
make
it
break.
Folks
come
on
be
gentle,
so
the
the
main
idea
of
the
application
is
to
show
that
it's
a
very
simple
application.
It's
a
monolith,
application
that
it's
generating
some
data
from
the
browser
in
this
case
and
sending
that
data
into
a
radius
instance
that
is
also
running
in
Google,
Cloud,
okay,
so
that's
kind
of
like
my
production
environment,
the
thing
that
you
are
accessing.
A
It's
not
very
well
configured
as
you
can
see,
but
you
know
I
will
I
will
work
on
that
later.
So
the
idea
is
that,
at
some
point,
like
the
company,
the
business
will
say:
okay,
we
need
to
add
a
new
feature
into
our
new
application
right,
but,
like
developers
will
not
work
in
the
production
environment
where
all
of
you
are
accessing
right
like
we
will
just
need
to
a
separate
place
to
go
and
do
our
work,
and
in
this
case,
what
we
want
to
do
is
as
a
platform.
A
We
want
to
provide
a
way
for
development
teams
to
have
a
development
environment
on
demand,
so
they
can
say
to
the
platform:
hey
I
need
a
new
development
environment
to
create
and
implement
this
feature.
I
need
to
I
need
the
platform
to
provision
a
new
environment
for
me
and
I
need
to
get
all
the
secrets
or
credentials
to
be
able
to
connect
to
that
environment
right,
that's
kind
of
like
what
we
are
going
to
do
now.
I
will
just
show
a
demo
where
I
will
connect
to
the
platform.
A
Api
I
will
send
a
request
and
I
will
get
a
development
environment
back
that
is
being
configured
by
the
platform
team,
but
it's
automatically
provisioned
when
I
send
the
request.
So
that's
kind
of
like
the
demo
for,
like
the
first
demo,
we
are
going
to
just
request
a
development
environment.
Again
this
is
a
live
demo,
so
be
patient.
Let's
it
should
work,
it's
kubernetes
right,
so
it
should
work.
So
the
idea
here
is
that
I've
extended
kubernetes
in
some
way
by
using
some
tools
and
I
Define,
this
new
resource
type
in
kubernetes.
A
So
it's
called
environment,
as
you
can
see,
it's
just
a
kubernetes
resource,
a
kubernetes
manifest,
and
it's
basically
allowing
me
to
set
the
name
of
the
resource.
In
this
case,
team,
a
environment
and
I
can
set
the
type
of
the
environment
that
I
want
to
create
in
this
case,
with
the
label.
Like
that
says,
the
development
in
there
and
I
can
set
as
like
as
a
application
development
team.
A
Some
parameters
that
are
very
specific
to
my
team,
for
example,
I,
want
to
make
sure
that,
when
I
create
this
environment
there
is
a
database
like
the
red
is
database
in
the
same
way
that
we
have
in
the
in
the
production
environment,
because
it's
a
kubernetes
resource
on
my
platform,
API,
it's
exposing
a
kubernetes
API
I
can
just
send
this
resource
using
cubectl,
apply
or
any
other
kubernetes
tool
that
allows
me
to
send
a
resource
to
to
the
cluster
again
Wi-Fi.
Why
not.
A
Maybe
a
cluster
is
in
a
different
continent
or
a
different
city
or
something
it
was
working
before.
But,
as
you
can
see
there
like
after
we
get
the
return
back
there,
the
environment
was
created
by
the
platform
and
as
a
user,
because
again
it's
just
a
kubernetes
source.
I
can
just
list
all
my
environments
right,
so
I'm
listing
my
environment
there.
It's
not
ready
yet
because
it's
been
just
provisioned.
We
just
create
that
request
six
17
seconds
ago,
so
it
will
take
some
time
in
order
to
be
created
and
to
be
provisioned.
A
But
what
I
will
do
now
is,
as
I
mentioned
before,
as
a
application
development
team
as
soon
as
I
get
an
environment
created,
I
would
love
to
be
able
to
connect
to
it
and
in
order
to
connect
to
it,
I
will
run
a
command
because
I'm
using
a
very
specific
tool.
But
you
can
imagine
that
if
you
are
provisioning
a
cluster
in
in
Amazon
or
in
Google,
you
will
probably
need
to
run
a
command
to
connect
to
that
cluster
in
this
case
I'm
using
a
tool
that
is
called
big
cluster.
A
That
I
will
talk
a
little
bit
about
later
on,
but
that's
the
only
thing
that
I'm
doing
here,
I'm
just
connecting
to
the
environment
that
I've
just
created
for
this
application
development
team.
That's
why
using
big
cluster
connect
and
the
name
of
the
environment
layer
again
remote
cluster,
it
might
take
a
second
when
I
was
trying
it
before
it
was
almost
automatically,
but
you
know
it.
It
will
take
some
time
now.
Do
the
network
connectivity.
So
hopefully
it
works
at
some
point.
A
This
is
going
to
connect
and
we
will
be
able
to
interact
with
our
development
environment
right
like
we
are
not
connected
anymore
to
our
platform.
Api.
We
are
connected
to
our
environment
and
we
can
start
developing
our
new
feature
this
environment.
It's
going
to
contain
an
instance
of
the
application
that
was
running
in
production
configured
to
work,
so
I
will
be
able
to
test
any
change
that
I
do
kind
of
like
in
a
very
production-like
environment.
In
this
case.
A
A
Right
like
you,
can
go
and
change
the
monolith
application
and,
of
course,
you
can
go
and
change
it,
but
if
it's
a
like
a
large
application,
usually
you
will
have
a
long
process
to
change
that
functions
can
help
a
lot
with
extending
monolithic
applications
that
you
already
have
by
adding
features
that
are
not
included
in
the
same
source
code.
So
you
can
actually
iterate
functions.
A
Much
faster,
usually
functions
are
described
in
you
know
when
you
can
like
create
purely
functional
applications,
but
in
this
case
I
wanted
to
show
how
you
can
extend
an
existing
application
by
creating
a
function
that
creates
a
new
feature
and
it
allows
you
to
implement
something
that
is
not
by
changing
the
monolith
application
that
we
just
created.
So
the
application
development
theme,
it's
very
interested
in
just
extending
the
application
we
will
be
creating
a
function.
A
Good
thing
about
functions
is
that
you
can
can
create
functions
in
any
language
that
you
want
and
we
will
be
able
to
deploy
our
function
into
our
development
environment
because
our
platform
team
that
defined
what
the
environment
is
actually
install.
Some
tools
for
our
function,
runtimes
in
there
right
and
that's
kind
of
like
our
second
demo.
But
the
problem
with
the
second
demo
is
that
it
depends
on
the
first
demo
for
the
environment
to
be
ready.
A
So
we
will
see
all
right,
let's
see
if
I
can
connect,
hopefully
I
can,
but
it's
actually
not
connecting
to
the
cluster.
So
we
will
see-
let's,
let's
wait
for
a
bit.
I
I
will
probably
run
out
of
time
for
sure
now.
But
let's
see
if
it
connects.
The
idea
here
is
that,
as
soon
as
we
are
connected
into
our
environment,
we
should
be
able
to
use
some
tools
again
that
were
created
by
the
platform
team
or
at
least
decided
by
the
platform
team
to
create
functions
and
deployed
functions
into
our
environments.
A
A
Again
live
demos,
I
should
have
a
recording,
and
you
know
my
father
told
me:
you
should
get
a
recording
I
didn't
do
it,
unfortunately,
because
I
really
like
the
risk,
but
you
can
imagine
you
can
you
know
you
are
like
creative
people,
so
you
can
imagine
what
happens
when
you
connect
to
a
cluster.
You
can
interact
with
the
API
server
right,
so
it's
it's
not
connecting,
but
what
we
can
do
instead
and
you
can.
A
You
can
think
that
this
will
work
right
when
we
interact
with
a
new
API
server
and
with
a
new
instance
of
the
application
by
using
big
cluster,
we'll
be
able
to
access
to
that
instance
of
the
application
that
runs
inside
that
environment
with
a
completely
separate
URL
right.
So
we
can
actually
go
and
interact
with
the
application
in
the
new
environment
that
it's
not
connecting.
Unfortunately,
so
let's
do
the
second
thing.
A
A
So,
basically,
if
you
want
to
create
functions,
we
can
use
tools
that
are
specifically
created
for,
for
that
use
case,
so
I'm
creating
a
new
I'm
going
to
a
new
directory
I'm,
creating
a
new
directory
called
average,
because
the
feature
that
we
want
to
build
is
we
want
to
calculate
the
average
of
all
the
values
that
are
stored
in
this
environment
and
then
I
will
use
this
command.
That
is
called
func,
create
that
basically
will
create
a
new
template
for
a
function,
in
this
case
using
the
go
language
and
then
consuming
a
template.
A
Connect
whatever
okay,
you
haven't,
joined
the
session
to
see
this
so
anyways.
The
idea
here
is
to
use
that
command
line
tool
that
allows
you
to
create
functions
and
then
deployed
functions
to
the
development
environment.
So
the
demo
goes
like
this.
You
I
create
a
demo.
I
created
the
function,
I
just
modify
the
function,
so
it
actually
calculates
the
average
and
then
I
deploy
it
to
a
development
environment.
As
soon
as
the
function
is
deployed
in
the
development
environment,
I
can
interact
with
the
function
and
actually
make
some
requests.
A
So
I
can
see
the
the
average
being
calculated.
Unfortunately,
I
cannot
show
that
I
promise
you.
You
will
see
a
video
as
soon
as
I
create
a
recording
of
the
demo
from
my
hotel
room.
Finally,
just
for
the
sake
of
of
the
story
here
we
have
created
here
a
function
in
our
development
environment
right
and
that's
running
in
there
and
I
can
interact
with
it,
and
everything
is
fine,
but
as
soon
as
the
application
development
team
is
done
with
the
you
know,
with
writing
the
functionality.
A
The
platform
should
be
in
charge
of
taking
this
functionality
from
our
development
environment.
From
our
you
know,
development,
GitHub
repositories
into
our
production
environment
and
the
the
way
of
doing
that,
it's
very
different
from
the
tools
that
we're
using
for
developing
things
right,
like
I,
was
using
this
functionali
to
create
and
deploy
functions
in
my
development,
environment.
I.
Don't
I
do
not
want
to
do
the
same
things
for
our
production
environments,
so
for
production
environments.
A
What
you
usually
do
is
you
probably
apply
some
kind
of
like
githubs,
and
also
here
is
where
you
run
all
the
compliance.
On
top
of
you
know
the
things
that
you
are
deploying
into
into
into
your
production
environments,
so
for
this
demo,
like
the
third
demo
of
my
presentation,
actually
shows
a
tool
that
it's
called
Argo
CD
that
it's
configured
to
sync,
you
know
changes
into
our
live
clusters.
A
This
repository
that
it's
called
Cube
day,
Japan
production
and
inside
this
production
directory
that
it's
not
there
come
on,
basically
contains
the
configuration
files
for
for
deploying
this
application
into
our
production
environment,
and
then
we
have
a
tool
like
cargo,
City
or
flux,
which
is
basically
now
not
even
showing,
but
it
actually
have
the
configuration
to
go
and
check
into
this
repository
and
sync,
all
this
configuration
to
a
live
cluster.
Unfortunately,
the
network
is
not
collaborating
with
us
today
the
network
is
not
even
connecting
so.
A
There
is
not
much
that
I
can
do
there,
but
let
me
try
to
summarize
the
idea
here.
So
let
me
go
down
at
the
end
here.
So
two
things
here
that
I
want
to
talk
right
like
the
first.
The
first
idea
was
to
use
a
tool
that
is
called
big
cluster
to
create
virtual
clusters
to
create
development
environments.
A
By
doing
that,
you
are
kind
of
like
obstructing
away
all
the
complexity
and
all
the
things
that
they
need
to
understand
in
order
to
do
these
deployments
or
to
quickly
iterate
over
different
functions,
and
then,
when
we
are
going
to
more
like
into
a
production
environment
or
a
more
sensitive
environment,
using
tools
like
Argo
City
to
sync,
you
know
the
configuration
of
a
cluster
that
it's
storing
it
into
a
production
environment.
It's
a
much
more
safer
because
you
remove
the
manual
intervention
against
the
cluster.
A
A
So
one
of
the
key
points
here
is
that
if
you
are
planning
to
extend
kubernetes,
you
need
to
make
sure
that
there
is
no
other.
You
know
project
doing
something
similar
that
you
can
reuse,
because
you
will
save
a
lot
of
time
on
maintaining
components,
otherwise,
so
for
this
demo,
I've
used
cross
plane
to
create
that
environment
resource
cross
plane
is
a
project
that
allows
you
to
create
Cloud
resources
using
the
kubernetes
apis
right.
A
A
Cross
plain
allows
you
to
also
create
compositions,
which
is
pretty
like
a
very,
very
important
Concept.
In
this
case,
you
can
create
something
like
I
did,
like
I
created
a
resource
type
called
environment
that
basically
represent
a
bunch
of
cloud
resources
being
created
together
right,
so
I
created
a
a
local
like
a
development
environment
that
basically
created
a
virtual
cluster,
but
you
can
create
like
a
staging
environment
that
actually
goes
and
create
a
Google
Cloud
cluster
for
you
and
the
interface
for
the
users
will
be
the
same.
A
You
can
create
very,
very
similar
jaml
files
to
create
different
environments
and
to
provision
different
Cloud
resources
across
multiple
different
Cloud
providers,
and
that's
a
pretty
powerful
idea
and
that's
why
cross
planning
is
becoming
really
really
popular
in
the
platform
space
be
cluster,
as
I
mentioned
before.
It's
a
quick
way
to
create
virtual
clusters
inside
the
same
cluster,
so
you
are
creating
isolated,
API
servers
and
we're
using
the
kubernetes
scheduler,
like
the
main,
the
hosted
scheduler
for
for
all
these
API
servers.
A
This
is
pretty
good
when
you
want
to
isolate
workloads
and
when
you
want
to
isolate
like
API
access
right.
It's
it
comes
very
very
frequently
when
you
talk
about
like
using
namespaces.
It's
not
good
enough
for
your
use
case,
because
again
you
don't
have
enough
isolation
between
different
tenants
and
when
you
cannot
create
different
clusters
for
different
tenants,
because
that's
too
expensive,
you
need
multiple
control
planes.
So
this,
like
big
cluster,
is
an
open
source
project
that
gives
you
kind
of
like
some,
some
good
benefits
there.
A
You
can
have
isolation
without
paying
the
costs
for
creating
separate
control
planes
for
that
there
are
other
projects
like
hypershift.
Of
course
that
applies
a
different
approach,
but
it's
in
the
same
space.
Multi-Tenancy
right
like
this
is
also
very
important
in
the
platform
building
space
because
you
will
have
more
than
one
cluster,
so
that's
kind
of
like
what
I
was
doing
there
when
I
send
the
request
to
the
platform
API
like
cross
plane
was
using
V
cluster,
which
basically
is
just
using
Helm
to
create
a
new
v-cluster
and
deploying
my
application
into
into
the
environment.
A
So
you
can
reuse
the
same
installation
of
K
native
for
multiple
big
clusters
and
then
I
at
the
end.
I
use
Argo
CD
just
for
for
githubs
again,
just
to
sync,
you
know
kubernetes
resources
into
a
kubernetes
cluster
and
that's
the
thing
that
I
showed
you
before.
There
are
some
other
tools
that
you
should
be
checking
out.
If
you
are
looking
into
building
platforms
like
open
feature,
is
something
that
it's
it's
growing
in
the
cncf
space.
Dapper
is
another
project
that
I
will
be
looking
onto,
which
is
more
in
the
developer
space.
A
So,
to
make
your
developer's
life
easier,
no
matter
which
language
they
are
using.
Cloud
events
and
CD
CD
events
are
other
initiatives
that
you
should
be
looking
at
and,
of
course,
if
you
are
building
platforms,
you
want
to
measure
how
good
the
platforms
are.
So
you
should
be
looking
at
Dora,
metrics
and
I'm
building
a
POC
showing
kind
of
like
all
these
tools
together.
A
If
you
try
it
out
on
on
your
local
laptop,
you
need
to.
You
need
to
have
a
lot
of
ram
to
run
all
these
components
locally.
But
actually,
if
you
have
like
32
gigs,
it
should
be
all
right
and
again,
the
idea
was
we
started
in
production.
We
changed
our
application
by
creating
a
development
environment.
A
They
shouldn't
wait
for,
like
they
shouldn't
create
tickets
and
wait
for
you,
know
the
operational
team
to
create
those
environments.
Automation
here,
it's
it's
key.
Thank
you
very
much.
I
apologize
for
the
demo,
not
working
I,
can
actually
install
it
locally
later
on
and
show
it
to
you
if
you're
interested
apologize
once
again,
I
will
share
the
recording,
that's
the
the
link
to
the
book,
and
you
know
that's
my
Twitter
handle
if
you
have
any
questions.
A
A
B
Worry
too
much
about
the
demo.
I
think
the
one
thing
I
didn't
quite
understand
with
the
concept
was
I
think
where
Argo
CD
is
involved.
So
the
are
you
creating
a
new
manifest.
That's
like
automatically
like
kind
of
understands.
Okay,
this
is
what
the
function
is
supposed
to
do
and
it
builds
out
whatever
the
custom
resource
would
be
for
that
and
copies
over
to
production.
I
think
I'm,
just
confused
about
that
interaction,
perfect.
A
No
I
think
that
the
question
makes
a
lot
of
sense
because,
like
the
demo
kind
of
quite
cover
that
so
the
idea
is
that
we
use
function
CLI
to
deploy
to
our
development
environment
right.
In
that
case,
we
do
not
create
any
xaml
file.
The
CLI
actually
do
a
deployment
to
the
cluster,
but
the
CLI
can
also
have
have
kind
of
like
a
dry
run
mechanism
that
actually
gives
you
the
yaml
that
you
need
in
order
to
deploy
that
function.
A
So
in
order
to
move
the
function
that
it's
running
in
our
development
environment
to
our
production
environment,
the
only
thing
that
we
need
to
do
is
something
that
I
showed
in
the
demo.
Is
we
go
to
the
git
repository
that
contains
the
production
configuration
and
we
move
that
yaml
file
into
that
production,
environment
right?