►
From YouTube: Keptn Lifecycle Controller v0.1.0 Demo - October 2022
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
demonstration
of
the
captain
lifecycle
controller.
The
kept
lifecycle
controller
makes
it
easy
to
manage
the
life
cycle
of
cloud
native
apps
without
writing
operator
code.
We
all
know
that
operators
are
very
nice
concept
and
work
perfectly
fine
for
commercial
aftershave
software,
but
they
are
very
hard
to
adopt
when
the
life
cycle
of
an
application
changes
and
very
hard
to
write.
A
A
The
captain
livestock
controller
will
make
the
apply
effective,
better
Observer,
with
traces
and
Matrix
in
the
future.
So
what
we
will
see
here
or
today
is
that
we
can
do
all
of
this,
so
pre-post
deployment
tasks
and
the
deployment
of
an
application
doing
a
simple
Cube
cuddle,
applying
minus
F
Dot
in
our
pre-deployment
task.
Today,
we
will
check
if
one
of
the
workloads
is
ready,
so
we
will
deploy
a
simple
Potato
Head
application,
which
has
around
six
Services.
A
One
of
them
is
the
entry
service
and
all
of
the
other
services
or
workloads
will
check
if
this
service
is
available
before
they
start
deployed
after
the
deployment,
we
will
run
one
post
deployment
task,
which
is
one
simple,
select
notification
in
my
case,
so
I
think
I've
talked
enough.
Let's
go
to
the
demonstration,
so
the
LA,
the
captain
lifecycle
controller,
can
be
installed
very
easily
with
two
cubesatel
commands.
The
first
one
is
for
installing
this
web
manager,
which
is
a
dependency
at
the
moment.
The
second
one
is
the
lifecycle
controller
itself.
A
A
The
first
one
is
the
app
which
specifies
to
which
application
this
belongs
to
the
second
one
is
the
workload
name.
So
in
my
case,
this
is
the
potato
head
entry
here.
The
third
one
is
the
version
of
this
application
of
this
workload.
Sorry
and
the
fourth
one
is
the
post
deployment
task
which
will
be
triggered.
So
this
is
called
post
deployment,
Halo
Empire
case
here
for
the
entry
service.
We
also
added
the
init
container
to
see
that
that
we
can
wait
until
this
is
deployed
with
our
post
deployments
checks.
A
Then
we
have
another
few
services,
such
as
the
Potato
Head
head
service,
which
is
also
annotated
with
another
workout
name
same
version
name,
but
it
also
has
some
pre-deployment
task,
and
this
is
called
check.
Entry,
so
is
in
this
case,
and
this
will
check
if
the
entry
service
is
reachable
before
it
gets
before.
The
head
service
gets
deployed
foreign,
so
we
talked
about
tasks
here
and
they
have
to
be
specified
in
some
form.
A
So,
when
I
take
a
look
on
the
check
entry
armor
here
as
here,
the
typical
Captain
task
definition
and
the
name
I
am
using
here
so
check.
Entry
service
is
exactly
the
same
as
I
used
in
the
annotations
before,
in
this
case,
I
specify
that
this
task
definition
uses
a
function
which
is
referring
to
an
HTTP
source,
and
this
is
located
in
my
in
our
lifecycle
controller
repository
and
contains
the
function
for
http.
A
Furthermore,
we
pass
over
one
parameter
to
this
to
this
function,
which
is
the
URL
we
want
to
check,
and
if
we
take
a
closer
look
on
this
function,
we
see
that
this
is
a
simple
task:
a
typescript
function
in
Arduino
runtime,
which
gets
data
from
an
environment
variable
which
is
called
beta.
So
this
is
the
thing
we
did
here
in
our
parameter.
A
We
specified
here
in
our
parameters
and
in
the
end,
we
simply
try
to
fetch
the
URL
we
got
here
and
until
we-
and
until
this
is
not
finished
successfully,
we
will
also
we
will
always
exit
with
an
error
which
will
cause
the
port
to
restart
okay,
so
these
and
for
the
Post
deployment
task.
A
A
Okay,
so
I
think
we
have
everything
we
need,
so
we
can
try
to
find
and
try
to
execute
all
of
this.
A
So
what
you
see
in
my
shell
screen
here
is
on
the
right
upper
side,
the
ports
which
are
which
get
created.
So
at
the
moment
the
namespace
is
empty
and
in
the
lower
part
of
the
of
the
window,
we
see
the
captain
workload
instances.
So
the
version
of
one
workload
which
are
currently
deployed
and
in
which
state
they
are
and
in
the
directory
I
am
at
the
moment
there
are
all
of
the
files
you
saw
in
the
repository
before
one
file
is
new
here.
A
And
with
my
teeth
as
a
lot
is
happening
here,
so
on
the
right
upper
side,
we
see
that
one
container
is
initializing.
This
is
the
entry
Service
as
we
specified,
and
this
will
wait
for
around
30
seconds.
All
of
the
other
things
are
pending,
because
this
is
services,
not
services,
not
running
at
the
moment.
What
we
see
on
the
upper
part
of
this
is
these
are
the
pre-deployment
tricks
which
are
currently
erroring,
because
the
service
is
not
started
at
the
moment
and
not
reachable.
A
So
after
the
30
seconds
and
after
the
unit
container
has
finished,
we
see
that
this
is
in
a
running
state,
which
is
also
reflected
in
the
record
instance
state.
So
we
see
that
the
pre-deployment
has
succeeded.
The
deployment
itself
also
has
succeeded,
and
the
poster
brand
is
also
finished
and
in
the
right
lower
side
of
the
of
the
screen.
You
should
see
my
slack
window
where
you
see
that
I
got
a
notification
that
the
entry
service
is
deployed.
A
Now
that
the
service
is
reachable,
all
of
our
pre-deployment
checks
could
be
completed,
and
what
we
see
now
is
that
all
of
the
other
ports
are
also
starting.
Now
and
now
part
workable
workload.
The
other
service
will
also
succeed
and
in
the
end,
as
we
have
no
post
deployment
tasks
for
these
Services,
everything
is
running
perfectly
fine.
A
A
What
we
also
saw
very
well
is
that
the
lifecycle
controller
holds
back
the
deployment
until
the
pre-deployment
tasks
have
finished
and
last
but
not
least,
everything
can
be
done
using
cubes
details,
so
we
did
not
run
any
pipeline
tooling
and
we
did
not
run
any
external
tooling.
We
all
did.
We
did
everything
in
a
cloud
native
way
applied
only
manifests
and
in
the
end
our
deployment
got
finished
very
well.
A
So
if
you
liked
this
demonstration-
and
you
think
that
you
want
to
try
it
and
try
this
out
and
I
hope
you
will
everything
you
saw
here-
is
in
the
repository
of
the
captain
lifecycle
controller,
and
if
you
want
to
participate
in
this
project
and
in
everything
we
do
around
application
lifecycle.
There
is
a
working
group
around
this,
so
on
the
app
lifecycle
working
group
after
you
try
it
all
of
this.
A
It
would
be
very
nice
if
you
would
share
your
thoughts
and
you
could
pin
me
always
on
the
captain's
leg
or
also
participate
in
the
app
lifecycle
working
group
channel
on
the
captain,
live
on
the
captain's
leg
and
last
but
not
least,
let's
make
it
better.
So
if
you
find
some
issues
or
if
you
think
that
some
some
things
could
be,
could
be
solved
better,
just
open
up
an
issue,
I
think
you
can
also.
A
You
can
also
do
code
contributions
and
if
you
would
like
to
see
some
more
features
and
so
on
philosophy,
read
opinion
on
the
captain's
leg
and
let's
discuss
these
things
so
I
hope
you
had
as
much
fun
as
me
and
I
hope.
You
have
a
lot
of
fun
with
the
captain
lifecycle
controller
and
have
a
nice
day
and
see
you
bye.