►
Description
Learn more: https://keptn.sh
Get started with tutorials: https://tutorials.keptn.sh
Join us in Slack: https://slack.keptn.sh
Star us on Github: https://github.com/keptn/keptn
Follow us on Twitter: https://twitter.com/keptnProject
Sign up to our newsletter: https://bit.ly/KeptnNews
A
Hello,
everyone
today
I'm
very
excited
to
give
you
the
first
preview
of
function,
execution
with
the
captain
lifecycle
controller.
The
captain
lifecycle
controller
is
a
new
project
under
the
hood
of
the
organ
of
the
captain
organization,
which
helps
you
ensuring
that
your
account
native
applications
are
running
perfectly
fine.
So
when
we
are
dealing
with
kubernetes,
we
are
often
deploying
workloads
such
as
deployments.
Stateful
sets
and
Demon
sets,
and
we
might
have
many
of
them
which
could
be
grouped
into
applications.
A
Furthermore,
it's
able
to
run
application
and
virtual
health
checks,
so
these
are
all
nice
things,
but
what
can
we
do
with
it
so,
for
instance,
for
pre-deployment
or
yes
for
pre-deployment,
we
can
do
run
some
Security
checks.
We
can
do
some
infrastructure
checks
such
as
finding
out
if
the
infrastructure
is
ready
for
deploying
on
it,
we
could
check
for
problems
in
our
circulate
provider,
but
also
check
for
open
issues
in
our
issue
tracking
system.
A
For
post
deployment
we
could
use
among
functional
tests,
we
could
do
performance
tests,
but
also
as
low
validations
and
notifications
and,
last
but
not
least,
for
the
application
workflow
test
checks.
We
might
be
able
to
run
notifications
on
Pottery
stop
but
also
create
service
tickets
on
their
work.
A
A
So
in
my
demonstration
now,
I
will
simply
trigger
a
typescript
function
by
applying
a
manifest
two
kilometers
and
afterwards
take
a
look
if
this
function
has
finished
successfully
so
to
get
to
the
core.
A
I
have
my
task
definition
here,
which
has
a
kind
of
Captain
task
definition,
obviously,
which
is
called
hello,
Captain
inline,
and
this
has
a
specification
and
in
the
specification
we
see
that
this
will
be
a
function
and
we
reference
to
this
function
in
line.
So
we
have
the
function
in
our
custom
resource
definition,
and
this
is
a
very
easy
function.
So
this
simply
gets
some
data
from
from
an
environment
variable
which
is
also
specified,
which
is
also
specified
in
Captain.
A
A
This
task
definition
can
be
referenced
in
tasks,
so
we
have
a
captain
task
here,
which
is
called
hello,
developer
inline.
This
is
using
the
task
definition
we
created
before
it
will
be
relevant
for
the
workload
my
workload.
This
will
have
the
version
1.0,
and
this
will
be
for
the
application.
My
app-
and
these
are
the
parameters
we
saw
in
the
data
and
Json
objects
before,
and
we
say
yes,
the
name
of
our
developer
is
the
captain
developer
one
today.
A
A
This
is
exactly
the
same
object
and
the
same
for
the
task
and,
let's
simply
apply
this
on
our
communities.
Custom.
A
A
And
we
see
we
have
our
task:
hello,
developer,
inline
for
the
application,
my
app
for
the
workload,
my
workload
in
the
version
1.0.
This
created
the
kubernetes
job
with
this
name,
and
it
has
succeeded
in
the
meanwhile.
A
So
if
we
take
a
closer
look
on
the
job
name
and
the
corresponding
port
for
that,
we
also
see
that
this
printed
out,
hello,
Captain
developer
one
new,
and
when
the
state
of
this
task
and
job
is
succeeded,
then
everything
is
okay
for
our
for
our
captain
task
and
in
the
future,
our
captain
life
cycle
controller
will
be
instructed
to
run
them
to
run
the
deployment
well
to
say
that
the
deployment
has
finished
in
a
post
deployment
scenario.
A
So
getting
back
to
the
to
the
to
the
slides.
There
are
some
additional
features
we
have
in
the
function
execution
layer
at
the
moment
at
first.
We
can
also
reference
the
functions
on
HTTP
servers,
so
you
don't
have
to
specify
your
functions
inline.
You
can
also
have
them
lying
on
an
HTTP
server
and
execute
them
directly
from
there.
A
Furthermore,
you
can
reference
to
other
task
definitions.
For
instance,
you
can
have
your
template
function,
where
you
simply
specify
a
link
to
your
HTTP
server
or
to
inline
to
an
inline
function,
but
also
could
pass
more
specific
parameters
into
another
task.
Definition
reference
to
that,
and
last
but
not
least,
we
are
also
able
to
add
Community
secrets
to
them
to
pass
more
secure
data
over
to
the
functions
in
the
future
and
for
the
captain
lifecycle
controller.
A
You
will
be
able
to
reference
to
such
task
definitions
in
your
workload,
annotations
and
you
won't
have
to
deal
with
the
tasks
by
themselves
themselves
on
your
own.
A
So
if
you
think
this
is
a
cool
thing
and
you
want
to
help
or
contribute
to
the
captain
lifecycle
controller
and
to
the
function
execution
here
are
some
links.
So
what
you
see
here
is
work
in
progress,
so
this
is
the
first
pull
request
for
that.
We
have
a
separate
working
group
for
everything
which
is
related
to
the
captain
lifecycle
controller,
but
also
for
application
lifecycle.
A
You
can
find
the
link
to
the
GitHub
repository
here.
You
can
always
share
your
thoughts
with
the
with
the
captain
community
and
you
can
always
pin
me
on
the
captain's
leg
and
there
are
last
but
not
least,
we
have
a
select
channel
for
other
app
lifecycle
working
group
also
on
the
captain's
leg,
and
we
could
make
it
better
together.
A
So
thanks
for
your
attention,
my
name
is
maintainer
and
I
hope
to
see
you
soon.
Thank
you.