►
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe 2023 in Amsterdam, The Netherlands from April 17-21. 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.
Keynote: The Future of GitOps - Erik Jacobs, Senior Manager, Red Hat
The GitOps practice continues evolving and becoming more accepted and integrated into teams daily. Now that we have a more clear path to GitOps, how can we continue to evolve the practice to make it as easy as possible to integrate across the application development life cycle? In this session, we’ll explore possibilities to integrate across the application development lifecycle to further coordinate releases.
A
There
you
go
hi
good
morning,
so,
unlike
your
previous
speakers,
I
really
have
no
credentials
other
than
the
fact
that
I
work
at
red
hat,
but
we
happen
to
be
a
sponsor
and
they
asked
me
to
give
this
git
Ops
talk
so
I'm
here
today
to
talk
to
you
about
the
future
of
get
Ops.
I've
worked
with
Christian,
though
for
quite
a
long
time,
so
he
can
maybe
vouch
for
the
fact
that
I
know
at
least
one
thing.
A
So,
a
number
of
years
ago,
a
lot
of
interesting
technological
things
happened,
kind
of
around
the
same
time.
We
had
this
birth
and
emergence
of
containers,
another
container-like
Technologies
and
then
Google
and
red
hat
and
many
other
organizations
came
together
to
work
on
a
scheduler
to
deal
with
those
Technologies,
and
so
the
power
of
all
these
things
combined
gave
us
this
more
yaml.
A
No,
but
in
reality
what
they
gave
us
was
a
declarative
way
to
decide
to
run
workloads
and
through
the
power
of
this
type
of
vml
definition
and
kubernetes.
What
we
get
is
the
way
to
ask
sort
of
for
workload
to
be
run
within
a
pool
of
resources.
Right
give
me
this
container
image
that
I've
built
myself
previously,
that
is
available
in
some
registry
somewhere,
make
sure
this
many
number
of
them
are
running
and
keep
them
running.
A
So
again
you
know,
cool
things
happened,
Along
Came,
these
various
technological
providers,
Red
Hat
included-
and
we
said,
hey
we
understand
running
kubernetes
is
Pretty
Tough
we're
going
to
make
it
easy
for
you,
we're
going
to
handle
this
quote-unquote
infrastructure
and
make
it
available
as
a
service,
and
that
was
great
except
it
doesn't
really
solve
all
your
problems.
It
just
gives
you
the
stable
platform
on
where
you
can
run
things,
but
now
you
actually
have
to
run
things,
and
so
we
have
real
work
to
be
done
now.
We've
got
this
kubernetes
infrastructure.
A
We've
got
to
do
things
with
it
right.
We've
got
to
configure
it,
we've
got
to
actually
make
and
run
our
workloads
keep
them
going
and
we
want
to
be
able
to
maybe
audit
and
roll
back
and
Etc.
So
for
all
of
you
who
are
here,
obviously
you're
interested
in
git,
Ops,
Along,
Came,
Argo
and
flexing
these
other
get
UPS
like
technologies.
That
said
hey,
we
will
take
that
Declaration
of
desired
workload.
If
you
will
and
we'll
make
sure
that
that
happens,
and
if
we
detect
any
change
we'll
make
sure
to
reconcile
that
for
you.
A
So
in
this
case
we've
got
this
nginx
workload
that
we
want
to
have
three
of
and
no
matter
what
happens
in
the
cluster
Argo
is
going
to
make
sure
that
that
stays.
The
case
this
was
great,
so
kubernetes
was
doing
things
we
had
our
workloads
configured.
We
have
all
this
stuff
going,
but
not
everything
that
comes
in
kubernetes
is
exactly
what
I
want,
and
so
this
concept
of
a
crd,
a
custom
resource
definition
came
about
that
enables
us
to
extend
the
kubernetes
API
I,
don't
want
a
pod
I,
don't
want
a
deployment.
A
An
operator
is
just
a
controller
pod
that
runs
in
a
cluster
that
looks
at
these
crds
and
says:
okay,
I
know
what
to
do
with
that
chicken
sandwich
I
can
help
instantiate,
one
of
those
for
you,
and
so
now,
when
we
combine
crds
and
kubernetes,
we
really
can
start
to
build
some
superpowers
into
our
environment,
and
if
we
use
this
continued
example
with
Argo
being
sort
of
the
git
Ops
tool.
Here
we
can
have
this
new
thing,
which
is
a
stream
sorry
akafka,
which
kubernetes
has
no
idea
about
out
of
the
box
right.
A
We've
defined
it
with
a
crd,
and
we
have
this
operator
pod
that
understands
how
to
deploy
Kafka
components.
Based
on
this
simple
definition
of
akafka
and
through
the
power
of
Argo
and
get
Ops,
we
can
make
sure
that
those
Kafka
instances
are
always
running
as
intended
and
as
desired,
and
so
now
things
are
getting
really
interesting
because
nothing
says
that
those
operators
have
to
interact
with
only
things
that
live
inside
your
kubernetes
environment.
A
So
through
the
power
of
something
like
cross
plane,
you
can
have
a
definition
of
an
S3
bucket
which
ends
up
living
outside
of
the
cluster
in
a
completely
unrelated
set
of
infrastructure
in
the
cloud
somewhere,
and
so
really
what
is
the
future
actually
hold?
What
can
we
do
now?
Well,
we
can
think
of
git
or
Source
control
as
being
this
arbitrary
interface
into
anything
as
a
service,
anything
on
demand,
so
we
can
Envision
an
operator
that
does
whatever
and
some
company
says,
hey
here's
this
yaml
spec
for
how
to
get
one
of
our
things.
A
So
the
the
future
really
in
a
weird
way,
is
declarative,
and
we
see
this
in
in
many
of
the
ways
that
we
interact
with
technology
and
things
today,
but
this
is
kind
of
like
an
interesting
view
into
what
might
be
possible
in
in
the
near
future,
and
the
reality
is
that
it's
already
here
in
this
type
of
example
right.
So
whatever
you
can
Envision
in
your
own
infrastructures,
whether
that's
inside
your
own
premises
or
outside
you
know,
with
an
operator
and
a
crd,
you
can
pretty
much
do
whatever
it
is
that
you
want.