►
From YouTube: Introduction to FluxCD by Somtochi Amauche Onyekwere
Description
Somtochi Amauche Onyekwere, Developer Experience Engineer, Weaveworks introduces FluxCD.
---
KCD Africa 2022 is the 2nd iteration of the Kubernetes Community Days Africa, a CNCF-powered free community event. Visit https://kcdafrica.com for more information.
A
Okay,
so
yeah
shout
out
to
sahim
for
the
nice
talk
on
github
with
ago
cd,
so
yeah
the
aggro
cities
want
to,
and
flux
is
another
you
can
use
either
of
them.
They
are
both
open
source
projects
under
the
cntf,
so
my
talk
is
just
going
to
be
just
going
to
be
an
introduction
to
githubs
and
flux.
So
yeah
I've
done
this
before,
but
my
name
is
onika
sumtochi,
I'm
a
denver
experience
engineer
at
weave
works
and
I
work
on
flux.
A
So
I
want
to
sort
of
take
it
back
a
bit
and
sort
of
explain
what
guitar
forces
and
what
the
need
for
what
they
need
for
it
is
so
you
know
with
divine's
talk
he
had
like
he
was
deploying
an
app
and
he
did
you
know
cube
cto
apply
right,
so
that's
great
for
like
development,
workflow
and
everything,
but
then
how
do
you
take
it
to
production
like?
How
do
you
manage
this?
When
you
have
different
themes,
different
moving
parts?
Does
everybody
get
access
to
the
cluster?
A
You
know
someone
is
running,
cube
ctrl
here
and
creepy
keeps
it
here
there.
You
can
see
that
there
is
a
need
for
a
better
way
to
manage
how
things
are
deployed,
especially
within
bigger
organizations
right
and
then,
when
you
make
changes
to.
Let's
say
you
updated,
you
had
a
deployment
file
with
a
particular
tag
in
it.
Let's
say
you
wanted
to
update
the
tag
right,
so
you
updated
it
and
then
you
did
qctl
apply
right.
A
So
you
can't.
Let's
say
there
was
an
issue
with
that
tag
right.
How
do
you
quickly,
you
know,
revert
to
the
older
version,
so
there
becomes
issues
when
you're
trying
to
manage
all
your
manifest
using
cuba
city
apply
kelsey
kelsey
hightower
say
that
keep
ctl
apply
is
the
new
ssh.
You
know,
you're
not
supposed
to
ssh
into
servers
and
stuff
like
that
in
the
same
way
is
not
very
scalable
to
keep
managing
your
application
and
deployment
using
keep
cube
ctl.
A
A
Let
me
see.
Do
I
have
a
slide
for
that?
Okay,
so
github.
These
are
like
the
github's
principle
right.
Your
system
is
managed
declaratively
and
when
we
say
declaratively,
it
means
that
you
define
what
you
want
and
then
something
else
works.
That's
you
you're,
defining
a
states
that
you
want
to
cluster
your
cluster
to
be
in
right
and
you
store
it
in
gates.
Git
has,
of
course,
we
use
git.
We
know
that
git
has
like
versioning,
you
know
you
can
tag
commits
and
then
each
commit
is
easily
revertable
right.
A
You
have
a
log
of
changes
of
each
change
that
has
been
made
to
your
manifest.
So
that's
where
we
come
about
security.
You
know,
before
someone
makes
a
change.
You
know
the
person
has
to
make
a
pull
request.
You
can
get
eyes
on
it.
You
know
if
something
breaks,
you
sort
of,
can
look
at
your
commit
log.
I
know
okay,
this
is
what
we've
been
doing.
A
This
is
how
the
deployments
have
been
progressing
and
then,
if
you
push
it
to
get,
there
has
to
be
something
that
pulls
it
in
pulls
your
changes
from
gits
and
then
applies
your
changes
on
the
cluster,
which
you
know
now
bring
spins
up
your
application.
You
know
it
applies
the
deployment
yaml.
It
applies
the
services
and
all
of
that
on
the
cluster,
and
then
you
know
spins
it
up,
and
then
you
can.
A
You
can
consider
to
access
it
then.
Lastly,
we
talk
about
continuous
reconciliation
right,
you
don't
just
it's
not
a
one-shot
operation,
you
don't
just
push
your
files
to
git
and
then
they
get
applied
once
so.
There's
a
continuous
loop,
just
like
in
kubernetes
there's
a
reconciliation
loop
where
it's
constantly
being
checked.
Does
the
state
of
the
cluster
match
what
is
on
git
at
a
defined
interval
like
if
someone
comes
into
the
cluster
and
like
touches
something
you
know
like?
Maybe
your
part
is
deleted.
A
A
deployment
right
on
the
next
run
of
the
the
loop
the
agent
is
supposed
to.
It
could
be
flux.
It
could
be
august.
It's
supposed
to
realize
that
okay,
the
the
deployment
is
missing.
It's
not
in
the
cluster,
but
it
has,
but
it
it
has
been
defined
in
gates,
so
it
would
apply
it
or
in
a
case
where
the
deployment
is
deleted
from
gates,
it
will
delete
it
in
the
cluster.
So
it's
basically
the
git
serves
as
a
source
of
truth
for
it.
So
that's,
basically
what
github
is
beat
ups.
A
Is
you
define
your
applications
in
git
and
you
have
something
continuously
reconciling
them
on
the
cluster?
So
you
know
it
comes
with
many
benefits.
So
we
talk
about
security.
You
have
an
audit
log
of
each
change
to
your
manifest.
Any
malicious
changes
would
be
reverted
on
the
next
run
of
the
reconciliation
loop.
You
know
then
developers
it's
just
like
if
you
require
everyone
to
deploy
their
applications
using
skip
ct,
or
that
means
the
person
has
to
be
on
board
to
kubernetes
right.
A
It
means
that
the
person
needs
to
know
okay,
q,
q
d
skill
that
deployment
this,
but
if
you
just
need
that
git,
that's
if
you
just
make
it
easier-
and
you
know
everybody
already
uses
gits
right.
So
it's
easier
to
onboard
people
and
also
because
there's
changes
are
easily
revertable
right.
If
you
revert
your
changing
gates
that
change
gets
applied
on
cluster,
so
you
know
that
you
can
easily
undo
mistake
right,
so
it
enhances
productivity
that
way
and
is
also
increasingly
reliable.
Right.
A
Just
imagine
you
know
a
really
bad
day
where
your
cluster
is
destroyed
right.
You
can
easily
get
back
up
to
speed
with
all
your
applications,
because
you
have
all
those
manifest
stored
somewhere
right.
You
can
basically
install
flux
and
point
it
into
your
repo
and
say:
okay.
This
is
the
state
I
want
this
custard
to
be
in,
so
you
can
see
that
it
helps
with
stuff
things
like
disaster
recovery.
So,
if
you
lose,
you
know
if,
let's
say
your
application
is
detailed
by
mistake
or
even
the
whole
cluster.
A
You
can
easily
reconcile
and
get
back
your
your
cluster,
so
benefits
of
fox
flux
is
split
into
six
kubernetes
controllers
for
those
who
are
just
knowing
what
they
are
just
hearing
about
controllers
for
the
first
time.
That's
basically
the
the
the
part
of
kubernetes
right
when
you
create
a
deployment,
a
a
deployment
creates,
you
know
pods.
So
when
you
create
the
deployment
I
mean
when
you
apply
the
manifest
on
the
cluster,
there
is
a
cube
controller
manager
on
the
cube
control
plane.
A
That
is
watching,
for
you
know
such
manifest
when
it
notices
the
that,
so
is
there's
a
controller
that
is
running
on
costa.
That
is
constantly
watching
the
deployments
right
and
reconciling
them
to
to
the
pods.
So
if
you
do
define
a
deployments
like
supposed
to
have
two
ports
right,
the
controller
is
watching
the
number
of
pods
and
it's
like
on
a
loop.
It
will
count
the
number
of
posts
if
it
sees
all
there's
one
more
pod
than
it
should
be.
Let's
say:
there's
an
extra
third
port
associated
with
the
same
deployment.
A
It
will
delete
it
or
if
it's
discovered
that
there's
one
less
spot,
it
will
create
an
extra
one.
So
it's
it
fits
into
the
kubernetes
model
where
kubernetes
is
already
declarative
and
it
uses
controllers
to
manage
its
resources
on
the
cluster.
So
that's,
basically
what
flux
would
do
for
you.
Flux
will
check
that
your
applications
are
running
as
they
should,
as
you
have
defined
them
in
git.
So
it
comes
with
support
for
customize
and
help.
We
have
a
helmet,
customized
controller,
it's
easily
extensible.
We
built
it
in
a
way
that
you
could.
A
A
So
just
in
summary,
flux
develops
githubs
for
both
apps
and
infrastructure.
You
know,
with
with
control
plane,
you
can
spin
up.
You
can
have
a
monitor
right.
You
have
a
cluster
that
creates
other
cluster,
basically
still
the
same
concepts
of
controllers
and
custom
resource
definitions
right.
You
create
a
controller
that
understands
a
new
resource.
A
So
when
the
controller,
the
controller,
can
you
can
tell
something
like
crosstalk
and
cosplay?
Has
a
cluster
resource
you
can't
and
when
you
apply
it
on
cluster
crosspin
will
create
clusters
for
you
and
make
sure
that
it
matches
what
you
what
you've
defined,
so
it
can
provide
githubs
for
both
your
apps
and
infrastructure.
A
A
A
These
are
trust,
flocks
and
there's
a
lovely
community
for
you
to
work
with
so
yeah.
I've
been
sure
sort
of
this.
So
it's
basically
you
it's
basically
going
over.
What
github
says
again
is
an
operating
model
for
cloud
native
applications
such
as
kubernetes
and
he
utilizes
version
controlled
system
as
the
single
source
of
truths.
A
A
So
yeah
guess
this
is
an
overview
of
flux.
Flux
is
a
set
of
controllers,
so
the
way
flux
is
flux
is
built
right.
Now,
it's
it's
itself
breaks
out
different
functionalities
into
different
controllers,
so
the
source
controller
pulls
in
your
your
git's
repository,
like
the
files
you've
stored
in
gates.
The
customized
controller
connects
to
the
source
controller
and
you
know
applies.
The
manifest
is
what
has
like
customized,
you
know,
using
customized
applied
manifest
in
cluster.
We
have
helm
controller
for
helm,
also
connects
the
source
controller.
A
The
notification
controller,
like
we
just
said,
is
for
alerting
you.
You
know
giving
you
some
notifications
on
what's
going
on
and
then
the
image
reflector
automation
controller
is
used
for
watching,
let's
say
you're
in
your
ci
in
your
continuous
integration.
You
you
build
an
image
right
and
push
it
to
push
it
to
to
the
image
registry.
Now
flux
watches
the
image
registry.
When
you
can't
tell
flux
like
oh,
I
want
for
this
production
cluster.
I
I
want
to
update
for
every
major
version
right.
A
So
one
point
this
or
one
point
that
you
can't
tell
flux
like.
I
want
you
to
watch
with
the
image
reflector
controller
you
want.
I
want
this,
you
to
watch
the
the
image
registry
and
like
notice,
when
there's
a
new
version
right,
so
you've,
you've,
you've
pushed
let's
say:
you've
pushed
a
new
version
of
your
app.
Your
ci
has
built
it
and
pushed
it
to
the
image
repository
now
flux.
What
flux
does
is
that
it
would
update
your
manifest.
A
That
is
the
image
automation
controller,
to
update
your
manifest
in
gitz,
with
the
new
image
tag
and
flux
view
and
the
flux,
the
source
controller
will
still
pull
the
new
manifest
and
applied
it
to
you
apply
to
your
custard.
So
basically
it
takes
that's
the
cd
patch
right,
continuous
delivery.
It
watches
your.
It
watches
your
your
your
image
registry.
If
you
saw
in
science
demo,
he
had
a
github
action,
that's
sort
of
tagged
that
updated
the
the
yaml.
A
So,
yes,
also
under
the
flux
cd
project,
we
also
have
flagger,
which
is
used
for
you
know:
progressive
delivery,
deploying
apps
with
canaries,
feature
flags
a
b
rollouts
and
also
it
can
manage
any
kubernetes
resource,
so
yeah,
it's
flux
enables
application
deployments
cd
and
with
the
help
of
flag
that
you
know,
flux
and
flutter
flagger,
they
go
well,
they
work
well
together.
You
can
also
have
progressive
delivery
and
all
of
this
happens
automatically
right.
Progressive
delivery.
A
Just
to
expand
on
it
a
bit
is
when
you
know
you're
deploying
you're
deploying
a
new
version
of
your
app
right,
but
you
you
won't.
You
don't
want
to
push
all
the
traffic.
You
don't
want
to
switch
over
immediately.
You
know
what,
if
there's
a
problem,
so
in
progressive
delivery,
you,
you
know
gradually
shifts
the
traffic
in
in
a
particular
way.
If
you
notice
there's
an
issue,
you
can
quickly
reverse
right
because
you,
you
notice
it
on
time
and
the
other
one
is
still
running
you
can't
easily
revert.
A
You
can
do
this
gradual
process
of
moving
from
one
version
of
the
app
to
the
other,
so
flux
can
push
back
to
git
for
you,
which
is
what
we
talked
about
with
the
image
registry
right
when
he
notices
a
new
tag
for
the
image
right,
it
could
do
the
pushing
back
to
pushing
to
get
for
you
it
would.
It
would
update
your
manifest
for
you,
so
it
works
with
your
tools.
A
So
for
yourself
for
yours,
the
source
of
your
money.
First,
you
can
use
github
gitlab
beats
buckets.
You
could
use
your
own
self-hosted
git
servers.
You
know
for
people
who
are
working
in
like
more
constrained
environments.
You
know
all
major
container
registries
to
ecr
acr
gcr.
You
know
all
the
major
providers,
so
it's
basically
can
plug
in
into
whatever,
like
setting
you're
already
using.
You
know
and
become
this
valuable
part
of
your
deploy
deployment
process.
A
So
it's
we've
said
before
it
works.
We
customize
helm.
These
are
customizer.
Helm
are
two
clies
that
people
use
in
helping
them
deploy
kubernetes
manifest.
So
it's
also
work
switch.
Each
of
them
uses
our
back,
which
is
raw
based
control
to
you
know,
control
access,
so
it
does
more
tenancy.
You
can
set
flux
up
in
most
tenants
wage
such
that
you
know,
flux
is
reconciling
manifest
for
different
tenants,
but
in
a
secure
way,
so
it
for
to
expand
on
multi-tenancy.
A
Most
tenants
is
when
there's
is
what
we
call
more
than
one
tenants
running
in
a
cluster.
You
know
you
might
be,
you
know
a
very
large
company
and
you
have
different
teams
different
as
namespaces
assigned
to
different
teams,
and
they
are
supposed
to
deploy
their
applications
in
their
particular
namespaces.
You
know
they
are
that's
the
most
tenants
cluster.
You
get
the
one
person
doesn't
own
the
whole
cluster.
They
are
different
people
using
the
cluster.
A
So
in
multi-tenant
situation
you
have
to
be
careful
so
that
one
tenants
in
it
depends
on
what
kind
of
there
are
different
levels
of
monster
tenancy,
but
you
have
to
be
careful
so
that
one
tenant
does
not
access
the
other
tenants.
You
know
you
want
to
lock
down
the
costa
beats
and
flux
can
still
help
with
that.
A
A
A
Of
course,
we
are
a
loving
community.
That
is
oh
very.
We
are
like
I've
enjoyed
so
much
working
with
flux.
You
know
we
are
very
welcoming
very
open.
We
have
contributors
from
everywhere,
so
we
are
also
an
open
source
project,
also
open
to
new
contribution
contributors
coming
around.
We
have,
since
you
can't
see
my
screen.
We
have
you
know
good
first
issues.
A
A
Most
of
it
is
written
in
go
so
yeah,
so
we
are
also
looking
for
contributors.
If
you
like
what
we're
doing
you
like
the
sound
of
it,
you
can't
come
around,
you
know
just
attend
our
meetings,
figure
out
what
we're
up
about
and
if
you
feel
like
contributing
you
can
so.
This
slide
is
basically
going
over
what
I've
said
before
the
source
controller.
Fetches
your
files
and
gives
the
customized
controller
applies
the
manifest
you
can
see
that
there's
a
particular
controller
assigned
for
each
step.
That
flux
is
supposed
to
do
so.
A
Helm
is
for
helm,
charts
notification
controllers
for
the
notification
dispatch
image.
Reflector
controller
is,
for
you
know,
pulling
that's
the
metadata,
that's
the
tags
from
gits
and
then
the
from
an
image
registry,
and
then
the
image
automation
controller
is
for
sort
of
posting
box,
gits,
updating
the
git,
the
the
amazing
kit,
so
yeah.
All
of
these
controllers
work
together
to
give
you
a
nice
outcome.
A
If
you
like,
pancakes
yeah,
it's
it's
basically
like
all
these
ingredients
mix
up
to
form
something
really
helpful.
So
yeah
we
work
with
other
tools
and
all
these
reasons
I
love
flocks
and
other
people
to
like
talk
about.
We
we
hear
like
stories
back
from
people
like
oh,
like
this
has
made
using
kubernetes,
is
so
much
easier
for
me.
You
know
I've
been
able
to
run
multi-tenancy.
A
You
know
we
have
this.
If
you
have
an
application
right,
let's
say
you
have
an
application
that
depends
on
a
database.
You
can't
define
it
in
flock,
so
that
flux
knows
that
okay,
it
doesn't
deploy
the
application
to
till
the
database
is
ready
right.
So
you
can't
sort
of
have
a
dependency
workflow
like
right.
You
can
say:
okay,
don't
deploy.
This
app
depends
on
this
and
flux
knows
not
to
create
the
application
until
the
other
one
is
ready.
So
we
integrate
with
helm.
A
We
give
notifications
and
a
lot,
and
you
know,
flux
manages
itself
declaratively,
like
you
ins,
you
can
install
flux
with
the
bootstrap
and
flux
view.
You
know
the
bootstrap
asset
accepts
a
github
repository.
So
right
from
the
start,
like
flux,
manages
itself
in
githubs
so
which
I
think
is
kind
of
awesome.
So
we
also
have
the
flux
cli
to
make
dealing
with
flux
easier
for
users.
A
So
you
can
get
started.
You
can
look
at
our
repo,
you
have
a
getting
started
guide.
You
can
browse
the
docs.
You
can
join
flocks.
Cncf
slack,
you
know
the
users
there,
people,
you
know,
ask
questions
if
you're
having
any
any
issues
you
can
sign
up,
for,
we
are
meeting
on
our
main
list.
You
know
join
our
meetings
and
also
you
know,
discuss
with
us
on
github.