►
From YouTube: How to GitOps with Keptn? - Keptn User Group
Description
We get a lot of questions around GitOps with Keptn, how it relates to what ArgoCD and Flux is doing. In this session we have Thomas Schütz, a Keptn maintainer and champion of the Keptn GitOps Operator initiative and will talk how Keptn supports GitOps by deploying a declarative state into multi-stage environments. Thomas is a Principal Cloud Engineer at Dynatrace, and he initially started this project as a Keptn user. The presentation gives a status update on the current work being done through KEP-67 and KEP-69, and shows a live demo.
References:
- Keptn GitOps Operator: https://github.com/keptn-sandbox/keptn-gitops-operator
- KEP-67 "Keptn and GitOps" - https://github.com/keptn/enhancement-proposals/pull/67
- KEP-69 "Keptn Declarative Configuration" - https://github.com/keptn/enhancement-proposals/pull/69
How to contribute? We have a `#wg-keptn-gitops-operator` Slack channel on the Keptn Slack. Join us there! https://keptn.sh/community/#slack
Meetup page: https://community.cncf.io/events/details/cncf-keptn-community-presents-how-to-gitops-with-keptn-keptn-user-group-1/
A
And
welcome
everyone
to
today's
captain
user
group.
How
to
get
ups
with
captain
today
is
march.
16Th
I
saw
most
of
you
will
watch
the
recording
because
I
see
a
handful
of
people
here,
that's
great,
but
we
know
from
experience
that
most
people
watch
it.
If
you're
new
to
captain,
then
you
also
see
a
lot
of
links
on
the
bottom.
A
Captain.Sage
follow
us
on
add
captain
project
you
find
the
github
repository
and,
very
importantly,
we
also
have
a
dedicated
slack
workspace,
so
make
sure
if
you're
not
yet
on
the
captain's
leg,
slack.captain.sh
other
things
it's
march,
kubecon
is
just
about
two
months
around
the
corner,
which
means
in
case
you
are
at
kubecon,
also
be
reminded
that
we
are
there
as
well.
Hopefully
we
can
see
each
other
thomas
welcome
to
the
just
quickly.
Think
almost
there
almost
the
next
slide.
But
do
you
want
to
quickly
say
a
couple
of
words
on
yourself.
B
Yes,
so
hello,
my
name
is
thomas,
I'm
a
principal
engineer
at
banatris
and
the
captain
maintainer.
But
as
this
is
the
captain
user
group,
you
might
wonder
why
I
am
here
and
I'm
a
really
I'm
an
adopter
of
captain
in
diner
trees.
So
I
also
collected
a
lot
of
experience
there
and
wanted
to
show
you
how
how
we
do
github
sedina
trace.
A
Perfect
and
to
kick
it
off,
maybe
if
you
want
to
switch
to
the
next
slide
now,
I
think
captain
has
really
come
a
long
way,
especially
around
gitops,
and
what
you
are
going
to
show
today
is
really
where
a
lot
of
our
users
want
to
be
in
terms
of
how
to
actually
work
with
captain.
I
think
what,
if
you
are
sticking
with
us,
what
thomas
will
show
us
how
you
can
just
do?
B
Thank
you
andy.
So,
yes,
we'll
do
some
magic
today
and
I
will
show
you
how
all
of
this
will
work
so
at
first.
So
what
we
will
what
we
will
see
today,
we
will
take
a
look
about
the
status
quo
of
captain
today,
so
how
captain
works
at
the
moment,
we
will
take
a
look
on
some
challenges
which
are
brought
with
this.
B
B
B
So
two
questions
a
developer
or
an
obscure
might
ask
when
he
wants
to
use
captain
is
how
do
I
update
the
helm
chart
and
how
do
I
execute
it,
and
how
can
I
reproduce
my
deployments
so
about
one
year
ago?
I
think
I
was
set
at
the
at
exactly
the
same
place
as
now.
So
in
a
captain
user
group-
and
I
talked
about
a
keytops
operator
for
captain
and
yes
in
the
meanwhile,
we
got
we
got
all
of
this
running.
B
B
This
is
running
really
stable,
but
this
approach
is
mainly
dealing
with
the
artifact
part
of
captain.
So
as
you
as
you
might
know,
captain
we
are
dealing
with
helium
chart.
We
have
charts,
we
have
tool
configurations
and
so
on,
but
we
are
not
dealing
with
the
captain
configuration
itself.
So
we
are.
We
have
no
real
declarative
approach
for
captain.
B
B
So
as
we
are,
as
we
all
know,
github
is
an
approach
which
define
which
needs
declarative
configuration
of
everything
and
says
that
the
git
repository
is
the
source
of
truth
for
captain,
and
in
this
case,
in
this
case,
it's
important
to
say
that
in
our
case
not
the
upstream
repository
is
the
source
of
truth
for
the
for
the
developer.
We
have.
We
have
a
an
additional
repository
for
that.
The
upstream
repository
of
captain
is
simply
acting
as
an
internal
storage
for
captain
and
therefore
is
not
not
really
used
by
our
keytops
approach.
B
On
the
other
hand,
as
a
as
a
captain
user,
you
might
know
that
you
can.
Let
captain
do
your
promotion
and
can't
can
do
some
some
triggered
on
like
events
and
therefore
let
captain
take
this
action
and
we
thought
we
want.
We
do
not
want
to
take
the
decision
for
the
for
the
user,
so
the
the
user
should
take
this.
B
B
B
B
So
you'll
you'll
get
it
really
pretty,
if
not
just
ping
me
on
the
captain's
leg
and
I'll,
send
it
to
you
after
the
presentation.
Okay.
So
when
we
take
a
look
at
the
picture,
everything
starts
in
the
left
upper
side,
so
we
have
a
def
centric,
a
dev
centric
part
of
the
whole
of
our
whole
cicd
process,
which
has
a
code
repository
and
after
everything
is
built.
After
after
we
did
our
unit
tests,
sometimes
integration
tests
and
so
on.
B
B
So,
as
you
see
here,
we
wrote
two
operators
for
captain,
one
which
deals
with
the
whole
kit
part
and
one
who
deals
with
captain.
So
the
first
one,
the
git
operator,
checks
in
a
regular
on
a
regular
basis,
the
configuration
repo
and
tries
to
find
out
if
something
changed,
and
if
something
changed.
We
have
two
two
things
we
we
have
to
do
afterwards.
B
The
configuration
we
have
in
our
configuration
repo
on
kubernetes
and
therefore
create
stages,
project
services
and
everything
we
know
in
captain
afterwards,
on
these
resources
we
have
a
second
operator,
so
the
captain
operator,
which
interacts
very
tightly
with
the
captain
control
plane.
So
at
first
it
takes
all
of
the
configuration
we
pushed
into
the
control
plane
and
knows
what
he
has,
what
what
has
to
be
done
to
get
captain
exactly
into
this
state.
B
Finally,
everything
is
happening
as
we
know
it,
so
we
have
a
captain
execution
plane.
This
can
be
a
different
q,
a
disgusted
and
then
the
captain
control
plane.
It
can
also
be
the
same
one
and
the
execution
plane
pulls.
The
configuration
from
the
from
the
captain
control
plane
also
push
pulls
the
artifacts
from
the
upstream
reaper
and
deploys
it
to
the
kubernetes
cluster
and
also
takes
the
container
images
there.
B
So
at
some
point
in
time
you
see-
and
after
this
talk
you
might
think
this
is
a
really
cool
approach
and
I
want
to
get
started
so
you
might
want
to
install
this
and
therefore
some
steps
has
to
be
have
to
be
done,
which
I
already
prepared
in
my
demo
now.
So
the
first
thing
you
have
to
do
is
you
have
to
create
the
key
pair,
because
we
will
deal
with
secrets
in
our
configuration,
so
you
might
have
github
tokens.
B
B
Furthermore,
we
install
a
helm
chart
and
yes,
another
thing
which
is
very
important
in
this
case.
The
operators
we
will
install
here
don't
have
to
run
necessarily
in
the
control
plane.
So
you
can
also
have
your
git
repository
inside
of
your
lab
infrastructure,
and
you
can
run
your
captain
instance
somewhere
in
the
cloud,
and
you
can
use
the
operators
to
fetch
the
configuration
from
your
lab
infrastructure
and
to
trigger
something
in
captain
in
the
cloud.
B
B
So
this
is
my
captain
instance,
and
this
is
a
so
I'm
using
car
automation,
so
the
commercial
version
of
captain
for
this-
and
I
have
kind
of
a
kind
of
a
code
repository
for
all
of
the
all
of
the
things
I'm
showing
you
here
and
I
created
all
of
my
configuration
in
a
directory
called
dot
captain
and
you
can
call
it
call
the
directory.
However,
you
like
you
can
configure
it.
However,
you
like-
and
you
only
have
to
point
to
point
the
repository
into
the
correct
place.
B
Let's
open
this
and
we'll
see
some
interesting
things
here,
so
in
the
root
directory
of
the
dot
captain
directory,
we
see
all
of
the
captain
configuration.
So
we
see
the
captain
instance,
the
captain
project,
the
captain
sequence
a
service
and
this-
and
we
see
two
other
two
other
very
important
directories
here.
So
we
see
a
base
directory
and
the
stages
directory,
and
these
two
directories
are
needed
for
our
artifacts.
B
B
All
of
this
artifact
is
our
artifacts
is
so
as
soon
as
we
as
we
push
all
of
these
artifacts
in
the
in
the
in
our
captain,
repository
captain
will
get
them
to
know
as
the
version
zero
zero
one,
and
this
is
very
important
in
further
consequence,
and
in
all
of
these
directories,
we
see
a
lot
a
lot
of
configuration
which
we
would
have
to
pull
to
push
manual
manually
in
the
current
captains.
In
the
current
captain
cli
approach,
and
when
we
apply
all
of
this,
we
will
have.
B
We
will
have
our
potato
head
service
deployed
by
our
via
helm.
We
will
have
monaco
dynatrace
monitoring
this
code
configuration
for
all
of
this,
so
the
quality
gates
we
will
so.
The
all
of
the
configuration
which
has
to
be
done
for
our
quality
gates
we
will
trigger
inside
of
this
run,
is
also
specified
in
this.
In
this
repository.
B
B
B
B
B
B
We
we
have
written
an
rsa
before
all
of
that,
and
this
says
yes,
this
is
an
rsa
encrypted
string,
so
we
encrypted
the
api
token
using
the
public
key
and
we
are
using
the
public
keys
and
we'll
decrypt
it
on
the
other
side
using
the
private
key.
So
this
is,
you
know,
stored
in
a
way
that
we
can
check
it
in.
B
The
second
thing
the
second
interesting
resource
we
have
here
is
we
have
a
captain
project
here,
and
this
says
yes,
I
have
an.
I
have
a
captain
project
with
the
name
potato
head.
This
is
the
upstream
repository
which
is
mandatory
at
captain
at
the
moment
can
be
found
here,
and
this
upstream
repository
has
to
exist.
When
we
create
this,
when
we
we
have
a
user
with
the
name
captaincy
demo,
we
also
have
an
rsa
encrypted
string
and
we
are
using
the
default
branch
to
apply
for
all
of
the
things
we
are
doing
here.
B
When,
yes,
okay,
so
this
was
the
project
part.
Another
part
we
have
here
is
the
stage
part,
so
we
could
define
a
captain
stages
in
the
in
the
operator
currently
in
the
operator
approach.
The
stages
dave
hardening
and
production
are
hard
coded
because,
as
as
some
of
you
might
know,
is
that
the
sheetbot
is
currently
very
static
and
you
can
override
the
stages.
B
So
there
is
the
possibility
in
the
operator
that
you
can
define
your
own
stages
and
your
whatever
you
want,
and
another
very
interesting
part
you
see
here,
is
that
you
can
define
the
sequence
here
and
we
don't
wa.
So
we
we
wanted
to
avoid
code
duplication
as
far
as
we
can.
Therefore,
we
created
the
possibility
to
create
templates
for
sequences.
B
So,
yes,
you
define
your
stage
here.
You
say:
yes,
it
belongs
to
the
project
potato
head
and
you
referenced
your
sequence
called
potato
delivery
dev.
In
our
case,
we
also
have
hardening
in
production
because
we
have
some
triggered
on
there,
but
you
could
also
take
potato
delivery
dev
for
the
stage
hardening
and
production,
and
this
would
be
a
this-
would
be
a
lot
of
data
application
in
your
pipeline.
B
Okay
and
last
but
not
least,
we
need
services
to
deploy
something
and
we
can
define
our
service
here.
So
we
have
a
service
which
is
called
potato
head
which
is
in
the
project
potato
head
and
which
is
really
cold
potato
head.
This
was
one
of
the
crutches
we
built
because
in
kubernetes
you
could
have.
You
cannot
have
many
two
service
objectives
with
the
same
name,
but
we
could
have
two
captain
projects
with
which
contain
services
of
the
same
name.
B
B
B
So
the
first
approach
when
we
created
exactly
this
mechanism
was
we
have
some
kind
of
a
captain
sequence
execution
which
might
trigger
an
event
of
an
of
artifact
delivery
in
the
stage
dev
and
puts
on
some
labels
on
that.
But,
as
we
thought
or
as
I
thought
a
bit
more
about
this,
I
I
thought
this
would
not
be
a
really
declarative
approach,
because
in
this
way
I
would
say
yes
execute
this
command
this
this
command.
B
Now,
and
with
this
with
the
definition
of
the
captain
service
deployment,
we
created
the
option
the
possibility
to
declare
or
to
define
a
deployment
itself
in
a
declarative
way,
because
in
this
way,
in
this
case,
I
do
not
say
yes,
captain
deploy
my
version-
zero,
zero
one
because,
I
simply
say
bring
my
service
potato
head
in
the
project
potato
head
to
the
version:
zero
zero
one
in
the
stage
dev
and
if
you
do
not
promote
automatically,
you
could
also
duplicate.
This
block
put
this
into
a
second
stage
and
also
the
second
stage
would
be
deployed.
B
B
Oh
sorry,
you
saw
in
the
you
saw
in
the
browser
before
we
are
also
authenticating
with
the
username
captaincy
demo.
We
also
encrypted
our
password
with
rsa,
and
we
say
we
want
to
react
on
the
branch
main,
so
you
could
define
every
branch
you
want
and
captain
release
our
operator
will
listen
on
exactly
this
branch.
B
So,
let's
close
this
and
yes
as
you,
as
you
see
here,
our
captain
instance
is
empty
at
the
moment,
so
there
is
only
a
banana
trees
project
which
is
pre-created
by
the
cloud
background
automation,
but
there
is
no
other
project
in
there.
So,
let's
start
this
and
let's
do
a
simple
cubetale,
apply,
f
and.
A
B
Yes,
and
as
we
see
here,
you
saw
it
before
we,
we
did
not
have
a
project
potato
head,
but
now
we
have
a
project
potato
head.
We
have
a
service
which
is
called
potato
head
and
our
sequence
is
triggered
and
in
this
case
there's
one
thing
which
is
which
is
mandatory
for
this.
For
this
whole
approach,
and
this
is
kind
of
a
promotion
service
which
is
needed
to
put
to
put
all
of
the
versioned
artifacts
together
and
to
prepare
the
stage
branches
of
captain,
as
we
know
them.
B
The
second
step
we
are
taking
here
is:
we
are
creating
the
monaco
monaco
configuration
in
diner
trees
for
for
the
service
and
just
for
for
those
who
are
interested
everything
you
see
here,
except
the
promotion
step
is
done
while
the
captain
job
executed.
So
we
didn't
need
another
service
here,
so
we
saw
monaco
is
also
configured.
We
saw
that
we
have
eight
configurations
here
and
the
next
we
will
deploy
we,
we
are
deploying
all
of
this
via
helm,
and
yes,
this
this
will
run
in
the
kubernetes
cluster
afterwards,.
B
Let's,
let's
not
wait
for
that
I'll
I'll
show
you
later
what's
happening
there,
but
after
this
deployment
step
we
will
do
some
some
tests,
so
we
will
run
some
some
load
tests
using
k6
for
that
and
afterwards
we
will
evaluate
everything
try
to
find
out
if
our
slide
providers,
when
our
case
dynatrace,
says
that
everything
is
okay.
Let
captain
take
the
decision
if
we
can
move
or
move
on
to
the
next
stage
and
afterwards
we
will
deploy
everything
on
a
hardening
and
on
a
production
stage.
A
Okay,
quick
question
here,
because
you
mentioned
that
on
your
captain,
I
mean
you're
using
cloud
automation
here,
which
is
a
hosted
version
of
captain's
control
plane
by
dana
trace,
but
still
you
have
your
job
executor
and
also
the
promotion
service.
So
this
is.
This
is
the
only
thing
that
really
you
had
to
install
on
your
target
platform
right.
A
Okay,
so
that
means
if
the
operator
is
important,
that
you
install
that
and
and
then
and
the
operator,
as
you
said,
could
run
into
in
in
any
environment,
because
the
operator
is
really
just
there
to
monitor
your
git
repository
and
if
there's
a
change
on
that
branch,
it
will
push
the
configuration
to
the
config
report
of
of
captain
and
then
eventually
it
will
also
trigger
the
any
any
sequence
that
is
necessary.
In
case
you
made
any
config
any
version
changes.
A
A
B
A
And-
and
we
will-
I
know-
I
also
see
johannes
on
the
call
I
mean
this
just
solves
so
many
problems,
and
I
think
that
you,
you
put
it
your
two
great
sentences
in
your
presentation.
The
first
one
was
developers
want
to
deploy
code
and
not
learn
captain.
Obviously
you
need
to
learn
parts
of
captain,
but
it's
really.
A
B
Okay,
so
let's
get
back
to
the
slides.
So
what
did
we
learn
today?
So
we
we
configure
the
whole
captain
instance
fully
declaratively,
so
we
specified
everything
in
custom
resources.
We
push,
we
put
all
of
our
configuration
one
repository,
and
we
simply
pointed
the
operators
to
this
cap
to
this
repository
and
our
captain
got
configured
fully
automatically.
B
What
we
also
saw
was
all
of
the
secrets
we
had.
We
have
can
be
starting
kit,
so
one
thing
which
which
could
not
be
done
before
was
to
create
projects
via
kit.
This
can
be
done
now,
because
we,
we
also
know
how
to
store
how
to
store
secrets
there,
and
another
thing
we
learned
here
was
that
we
can
store
our
that
our
configuration
and
artifacts
are
handled
separately.
B
So
we
had
the
base
and
stage
stages
directory
for
our
artifacts,
but
they
also
can
be
in
the
same
repository,
so
everything
is
under
control
of
the
customer.
Yes,
this
doesn't
get
finished
now.
So
what
are
the
next
steps
for
you?
So
every
one
of
you
can
try
it
out.
Hopefully
there
is
a
git
repository
which
contains
all
of
the
github's
operator
stuff.
B
Don't
be
afraid
of
the
secrets,
we
also,
I
also
created
a
helper
which
helps
you
to
create
the
to
create
secrets
for
the
for
the
whole
githubs
approach.
So
you
can
create
the
keypair
with
this.
You
can
encrypt
secrets
with
this
and
you
can
also
decrypt
them
if
you
want
to
test
everything
of
that
after
you
tried
it
or
if
you
have
some
questions,
feel
free
to
ping
me
on
the
captain's
leg
or
also
you
can
ping
pinandi,
if
you
like
it
more,
but
you
can
also
ping
some
more
guys.
B
B
The
whole
operator
approach
will
also
participate
on
the
google
summer
of
code.
So
if
you
like
to
participate
and
make
make
the
quality
of
all
of
this
better
feel
free
to
to
join
here,
and
you
can
open
up
github
issues
and
also
yes-
and
this
will
also
make
everything
better-
and
I
just
wanted
to
simply
get
back
to
the
to
the
to
captain
now
to
show
you
what
happened
in
the
meantime.
B
A
Exactly
yeah,
you
did
all
the
hard
work.
I
think
well.
Thank
you,
first
of
all
for
all
the
effort,
because
I
think
this
is
really
making
an
impact
because
it
gets
captain
closer
to
to
what
we
want
captain
to
be.
There
has
been
a
lot
of
questions
over
the
last
months,
at
least
for
me,
where
people
were
actually
asking.
A
So
what's
what's
the
real
git
story
with
captain,
and
I
think
what
you
are,
what
you
just
showed
is
that
we
are
moving
towards
two
key
tops,
and
this
is
the
important
piece
the
people
are
also
always
asking
me:
what's
the
difference
now
or
how
do
we
play
with
argo?
How
do
we
play
with
flux-
and
I
think
the
the
nice
thing
here
is:
there's
there's
no
either
or
there's
an
end,
because
we
obviously
can
nicely
work
together,
and
I
think
that's
also
important
to
understand.
C
A
A
That
is
not
only
saying,
I'm
kicking
off
the
deployment,
and
then
I
assume
it's
sometimes
done,
and
I
need
to
figure
out
how
I
get
this
status
of
done,
but
captain
will
take
care
of
this.
I
think
this
is
also
very
important,
but
everything
is
declarative
and
really
awesome
work.
The
question
for
me
is:
what
do
we
need
and
what's
the
plan
also
maybe
looking
at
johannes
here,
who
is
also
on
the
board?
What's
the
plan
of
of
getting
this
to
potentially
being
part
of
core
of
captain?
Is
this
the
plan?
C
If
you
can
jump
in,
it's
definitely
not
only
evaluated
it's
in
the
core
of
captain
the
heart
and
we
do
have
it
on
the
radar.
But
currently
it's
more
exploration
state,
but
we
need
to
figure
out
how
we
really
want
to
have
it.
And
once
we
have
agreed
on
the
cap,
enhancement,
proposals
and
the
prototype,
then
it
will
slightly
get
into
the
core
of
captain
yeah,
very
cool
yeah.
C
A
The
other
thing
I
wanted
to
read
through
it,
and
I
know
thomas
you
said
it,
but
I'm
not
sure
if
it
was
understood
correctly
in
the
very
beginning.
You
said
this
is
something
we're
using
internally
and
with
we
we
mean
the
company.
We
work
for
it's
dynatrace,
where,
while
captain
is
obviously
we
drive
it
independent
of
dyna
trace,
but
we
also
adopt
captain
internally,
we're
actually
adopting
our
sas
hosted
version,
which
we
call
cloud
automation,
but
one
interesting
step.