►
From YouTube: Getting Started with GitOps and Flux
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Hello
and
welcome
to
getting
started
with
get
ops
influx.
I
am
going
to
be
giving
a
introduction
to
both
the
topics
so
get
ops
first
and
then
flux
and
then,
at
the
very
end
I
will
be
giving
a
demo
on
how
to
actually
get
started
with
flux.
My
name
is
priyanka
ravi.
A
I
am
a
developer
experience
engineer
at
weaveworks
and
before
my
time
here
I
was
actually
a
on
a
get
ops
delivery
team
at
state
farm.
So
I
am
a
flux
user
myself.
So
basically,
I'm
going
to
be
coming
into
this
with
a
lot
of
user
experience
from
that
time.
A
Why
get
ups?
Why
should
you
even
care?
Why
are
you
here
there's
a
lot
of
reasons
to
love,
git,
ops
and
there's
a
lot
of
benefits
that
come
with
it?
Individual
teams
and
organizations
who
implement
get
ops
experience
many
benefits,
including
stronger
security
guarantees
because
of
gitops's
get
ops
tools,
unique
ability
to
treat
everything
as
code.
It
basically
directly
impacts
security,
for
example.
A
If
all
configuration
and
security
policy
is
treated
as
code,
everything
can
be
held
in
version
control.
So,
basically,
any
and
all
changes
that
are
made
are
reviewed
and
inputted
into
an
automated
pipeline.
There's
no
manual
processes,
so
you're
less
likely
to
be
at
work
on
a
weekend,
which
leads
me
to
increase
developer
and
operational
productivity
because
there's
no
manual
processes.
A
It
actually
allows
developers
to
work
on
things
that
actually
matter,
such
as
the
actual
application,
and
it
enhances
developer
experience
because
you
wouldn't
have
to
be
there
on
a
weekend
debugging,
something
that
you
know.
Maybe
someone
entered
in
manually
and
you
don't
have
this
audit
trail
of
how
it
got
there
and
what
changes
were
made
because
of
all
the
things
that
I
also
just
mentioned.
It
also
improves
stability.
A
It's
there's
a
higher
reliability,
it's
more
consistent
and
because
it's
all
through
code,
it
also
is
very
standardized.
A
A
You
get
rid
of
all
those
manual
steps,
and
so
you
can
focus
on
things
that
matter.
Also
it's
extensible.
It's
super
versatile.
It
works
with
existing
tools,
it's
very
flexible.
Basically,
it's
a
modular
natural
extension
of
kubernetes
and
because
of
the
microservice
architecture
that
flux
has.
You
can
pick
and
choose
what
you
actually
want
to
include
to
tailor
your
own
experience
with
flux
and
it
comes
with
out
of
the
box
support
for
customize
and
helm
and,
like
I
said
it's
designed
for
kubernetes,
it
was
designed
entirely
to
be
a
natural
extension
of
kubernetes.
A
So
these
are
eight
things
that
we,
like
you
to
know
about
flux,
and
so
it's
basically
just
a
little
flux
and
short
flux
provides
get
ups
for
both
apps
and
infrastructure.
You
basically
just
get
push
and
flux.
Does
the
rest
flux
works
with
your
existing
tools
and
it
also
works
with
any
kubernetes
and
all
common
kubernetes
tooling.
It
does
multi-tenancy
and,
as
we
like
to
say,
multi-everything
and
you
can
use
it
to
alert
and
notify
and
users,
trucks,
trust
flux,
myself
included
as
well
and
flux.
A
Has
a
lovely
community,
that's
very
easy
to
work
with.
I
am
going
to
come
back
to
these
statements
at
the
end,
so
I
will
elaborate
more
on
them.
I
just
wanted
to
get
your
feet
wet
with
these
concepts
all
right.
So
what
is
get
ops
get
ops
is
an
operating
model
for
cloud
native
applications
such
as
kubernetes,
but
I
do
want
to
highlight
that
it's
not
just
for
kubernetes.
A
If
you
are
doing
a
multi-cloud
infrastructure,
you
can
still
use
get
ops
for
your
other
platforms,
but
because
we're
focusing
on
flux
we're
going
to
limit
this
talk
to
kubernetes.
A
Also,
it
utilizes
a
version
controlled
system
most
commonly
git,
but
you
can
utilize
other
sources
of
truth,
but
most
commonly
you'll
see
git
as
the
single
source
of
truth.
So
that
way
you
have
something
like
an
audit
trail.
All
those
changes
are
actually
recorded
and
you
can
go
back
and
actually
view
this
source
of
truth.
A
Also.
It
enables
continuous
delivery
through
automated
deployment.
Monitoring
and
management
by
a
version
controlled
system
most
likely
you're
already
using
these
these
tools,
such
as
git.
If
you're,
you
know,
your
developers
are
probably
already
using
it.
So
it's
something
that
you
can
kind
of
just
take
advantage
of
this
tool
that
you're
already
using
and
that's
the
beauty
of
git
ops,
and
so
also
it
manages
your
infrastructure
and
applications
declaratively
all
right.
A
Through
discussions
with
many
different
vendors
and
users
experiences,
you
can
go
to
opengidops.dev
to
learn
more
about
the
get
ops
working
group
and
about
these
principles,
but
I
just
want
to
say,
don't
feel
like
you
have
to
have
them
all
done
in
order
to
utilize
git
ups,
everyone's
journey
looks
different
and
you
can
start
using
get
ops
and
add
in
hardening
and
tweak
to
your
setup
to
meet
these
guidelines
as
you
go.
A
Basically,
there's
a
lot
of
benefits
you
get
from
having
your
desired
state
expressed.
Declaratively
such
as
you
know,
because
it's
written
in
code,
it's
reusable
there's
an
audit
trail,
there's
a
lot
of
reasons
that
it's
a
good
idea
to
have
it
written
expressed
declaratively.
A
But
it's
also
important
for
later
later
principles
that
we're
going
to
talk
about
such
as
a
software
agent
pulling
it
but
yeah,
there's
lots
of
benefits
and
reasons
to
do
it,
and
then
the
the
second
principle
is
that
a
desired
state
is
stored
in
a
way
that
enforces
immutability,
versioning
and
retains
a
complete
version
history.
A
So
basically,
because
it's
immutable,
there's
no
sneaking
and
a
change,
there's
no
way
for
someone
to
come
in
and
actually
add
a
change.
That's
not
a
part
of
this
complete
version.
History
and
versioning
has
a
lot
of
good
benefits
as
well.
You
can
always
revert
back
to
an
old
version
and
so
yeah
there's
lots
of
benefits
to
all
of
those
things,
and
then
the
third
principle
is
that
software
agents
automatically
pull
the
desired
states
declarations
from
the
source,
and
so
because
your
your
stuff
is
all
codified.
A
All
your
state
state,
your
desired
state
is
codified,
an
agent
can
come
along
and
actually
pull
in
what
you
have
stated
that
you
want
it
to
look
like
and
then
it
will
actually
apply
it
to
your
kubernetes
environment.
So
the
fourth
principle
is
that
software
agents
continuously
observe
the
actual
system
state
and
attempt
to
apply
the
desired
states.
So
basically,
something
like
flux
would
be
actually
continuously
observing
the
desired
system
state.
A
A
So
what
is
flux?
Flux
is
a
get
centric
package
manager
for
your
applications,
but
git
isn't
the
only
system
you
can
actually
use
with
flux,
but
basically
it
provides
a
set
of
continuous
and
progressive
delivery
solutions
for
kubernetes.
It
is
a
natural
extension
of
the
benefits
that
already
come
with
kubernetes
and
at
the
core
of
it.
Basically,
the
it
continuously
monitors
your
version
control
system
and
it
applies
the
desired
state.
That's
been
declaratively
stated
there.
A
The
nice
part
of
this
is
that
you
don't
have
to
worry
about
things
like
configuration
drift,
because
it
also
heart
applies
on
a
schedule.
So
if
things
have
gotten
out
of
sync
for
some
reason,
it
will
actually
set
it
back
to
your
desired
state
and,
as
I
mentioned
earlier,
flux
really
reduces
developer
burden
because
it
removes
the
need
for
manual
deployment
processes,
everything's
automated,
which
is
really
nice.
So
you
don't
have
to
worry
about
those
things.
A
A
These
are
the
the
different
controllers
that
flux
is
made
up
of,
but
I
will
come
back
to
this
and
I
will
go
over
these
in
a
little
bit
more
detail
later.
I
just
wanted
to
show
you
an
overview
that
it
is
a
microservice
architecture,
and
this
is
how
it
works
all
right.
Now
I
am
going
to
go
back
to
those
statements
that
I
promised
that
I
would
go
more
in
detail
with,
and
so
the
first
one
is
that
flux
provides,
get
ops
for
both
apps
and
infrastructure.
A
Flux
along
with
flagger,
actually
deploys
apps
with
canaries,
feature
flags
and
av
rollout,
so
you
can
utilize
any
of
your
progressive
delivery
needs.
Basically,
and
there
is
a
great
self-led
workshop
that
includes
flagger
and
would
be
a
great
resource
if
you
are
interested
in
trying
it
out
and
that
can
be
found
at
eks.handson.flagger.dev.
A
Also,
flux
can
manage
also
manage
any
kubernetes
resource,
so
basically,
everything
you're
already
using
flux
can
really
manage
that
it
works
very
well
with
the
whole
kubernetes
environment
and
it
was
created
with
all
of
that
in
mind.
A
Also
infrastructure
and
workload
dependency
management
is
built
in
so
one
nice
neat
feature
is
that
you
can
utilize
depends
on.
So,
if
you
let's
say
your
application
actually
relies
on
a
database
already
being
stood
up,
you
can
actually
utilize
depends
on
to
tell
your
deployment
that
hey.
I
want
my
database
to
already
be
stood
up
before
my
application
is
even
set
up,
and
so
until
that
database
is
ready,
it
will
not
actually
deploy
the
application.
A
So
you
can
rest
assured,
knowing
that
all
of
those
necessary
factors
are
met
already,
which
is
a
neat
feature.
The
next
thing
is
just
push
to
get
and
flux
does
the
rest.
It
really
is
that
simple
flux
enables
application
deployment
and,
with
the
help
of
flagger,
like
I
mentioned
earlier,
also
progressive
delivery
through
automatic
reconciliation.
A
So
it
really
just
continuously
is
looking
for
those
changes
and
then
just
applying
them
automatically
and
flux
can
even
push
back
to
get
for
you
with
automated
container
image
updates
to
get
so
it
can
do
image
scanning
and
patching,
and
so
basically,
the
image
reflector
controller
and
the
image
automation
controller
work
together
to
update
a
git
repository
when
new
container
images
are
available.
A
Also,
it
works
with
your
existing
tools.
This
is
this
is
the
great
beauty
of
the
whole
the
tool
it
works.
With
your
get
providers,
github
get
bitbucket
and,
like
I
mentioned
earlier,
you
can
even
use
s3
compatible
buckets
as
a
source,
so
it's
not
all
just
get,
but
all
major
container
registries
work
and
all
ci
workflow
providers
as
well.
So,
basically,
all
the
tools
that
you're,
probably
already
using,
is
just
now
drop
in
flux
in
it.
A
It's
going
to
take
over
managing
your
deployments,
which
is
great
flux,
works
with
any
kubernetes
and
all
common
kubernetes
tooling,
like
I
said
before,
it
was
really
created
with
kubernetes
in
mind.
Probably
all
the
tools
that
you're
already
using
in
kubernetes
plugs
will
work
with
so
it
it
works
well
with
customized
helm,
our
back
and
policy
driven
validation,
oppa
kyberno
admission
controller.
So
it
simply
is
just
really
it
just
falls
into
place,
and
it
just
works
very
well
with
all
the
existing
tooling
flux
does
multi-tenancy
and
multi-everything.
A
A
You
can
have
a
multi-cluster
infrastructure
and
apps
work
out
of
the
box
with
cluster
api
flux
can
use
one
kubernetes
cluster
to
manage
apps
in
either
the
same
or
other
clusters
spin
up
additional
clusters
themselves
and
manage
clusters,
including
life
cycle
and
fleets,
and
so
multi-tenancy
is
something
I'm
going
to
show
like
a
little
bit
in
the
demo,
just
a
like
a
brief
nod
to
it.
But
there
are
different
types
of
multi-tenancy.
A
You
can
do
soft
tendency
where
you
have
a
cluster
with
multiple
name
spaces
so
like
a
team
can
be
given
a
name.
Space
and
flux
can
do
that,
but
it
can
also
do
hard
tenancy
where
you
give
each
team
their
own
cluster
as
well.
So
it
can
do
multiple
types
of
multi-tenancy,
which
is
really
awesome.
A
Plus
alerts
and
notifies
flux
actually
provides
health
assessments,
it
can
alert
to
external
systems
and
it
can
do
external
events
handling
as
well.
Basically,
you
can
just
get
push
and
then
you
can
get
notified
on
slack
and
other
chat
systems.
This
is
a
really
cool
feature
because
you
can
actually
set
it
up
to
to
tell
you
when
a
change
has
been
made
and
flux
has
been.
You
know
any
situation
that
you
basically
need
to
know
about.
You
can
actually
set
alerting
on
which
is
really
cool,
and
then
users
trust
flex.
A
Flux
is
a
cncf
incubating
project
and
was
one
of
only
two
projects
alongside
home
categorized
as
adopt
on
the
cncfc
icd
tech
writer,
and
you
know
we
we
get
a
lot
of
feedback
from
users
and
myself
being
a
user
as
well.
I
I
can
really
attest
to
it.
Does
everything
that
it
promises?
It
does,
and
it
is
very
simple
and
easy
to
use
and
it
makes
life
just
a
lot
easier,
so
we
have
gotten
the
feedback
that
people
really
do.
Trust
this
tool
and
flux
has
a
lovely
community
that
is
easy
to
work
with.
A
We
welcome
contributors
of
any
kind.
The
components
of
flux
are
on
kubernetes
core
controller
runtime,
so
anyone
can
contribute
and
its
functionality
can
be
extended
very
easily
and
get
started
contributing
to
flux.
You
can
find
a
contributing
guide
in
our
docs,
but
yeah.
We
really
do
welcome
anyone
of
any
level.
We
are
very
happy
to
have
you
feel
free
to
reach
out
to
us
if
you
need
any
help,
getting
started
with
something
like
that,
all
right.
Now,
I'm
coming
back
to
what
the
actual
flux
controllers
do.
A
The
first
one
is
the
source
controller
and
what
it
does
is
it
fetches
resources
and
stores
them
as
artifacts,
basically
at
its
core.
The
source
controller
is
continuously
monitoring
the
git
repository
and
looking
for
any
changes,
and
then
it
pulls
in
those
artifacts
and
stores
them,
and
then
the
customize
controller
actually
applies.
These
manifests
and
it
runs
manifest
generation
using
customize.
So
that's
an
important
key
component.
I
want
to
mention
there.
A
We
get
a
lot
of
confusion
for
sure
around
the
kubernetes
customize
and
the
name
of
the
customized
controller,
so
the
customized
controller
actually
does
use
customize
kubernetes
customize
in
the
background.
So
what
I'm
talking
about
by
kubernetes
customize
is
the
method
of
actually,
you
know
telling
using
kubernetes
customize
you
can
tell
it
which
resources
you
want
it
to
apply.
You
can
do
patching
all
of
those
things,
so
everything
you're
really
familiar
with
with
kubernetes
customize.
A
Basically,
you
can
still
use
kubernetes
customize
yamls,
but
if
you
don't
what
the
customized
controller
is
doing
in
the
back
end
is
actually
just
creating
one
so
that
it
can
actually
apply
the
necessary
resources
and
if
it's
not
specified,
then
it'll
just
apply
it'll
create
a
customized
with
all
of
those
resources
that
are
in
that
file
path,
the
helm
controller,
it
does
the
deployment
of
helm
charts.
Basically,
it
allows
someone
to
declaratively
manage
helm.
Chart
releases
with
kubernetes
manifests
the
notification
controller.
A
Does
notification
dispatch
it
specializes
in
handling
inbound
and
outbound
events,
the
image
reflector
controller
and
the
image
automation
controller?
They
basically
work
together
to
make
sure
that
if
there's
an
image,
that's
a
new
container
image,
that's
available
it'll,
actually
update
your
git
repository.
So
basically
they
work
together
in
in
tandem
and
and
all
the
controllers
also
work
together
to
produce
an
outcome,
as
you
could
tell
like.
A
So
I
want
to
mention
that
flux
works
really
well
with
other
tools.
I
know
I
mentioned
like
a
couple
of
them
briefly
before
in
one
of
the
statements,
but
I
wanna
really
highlight
that
it
works
with
so
many
existing
tools.
Yeah,
I'm
not
gonna
list
them
all,
because
it's
really
a
lot,
but
but
it
really
does
fit
very
well
into
your
probably
your
already
existing
environment,
which
is
really
great,
and
I
wanted
to
hit
on
a
few
reasons
why
I
and
and
others
really
love
flux.
A
It
just
makes
life
so
much
easier.
It's
all
this
automation
and
it's
it's
really
simple
to
use.
It
really
is
just
like
drop
in,
and
then
it
does
what
it
says
it
does
and
then
multi-tenancy
is
really
simple
with
it
as
well.
I
from
experience
have
actually
set
up
multi-tenancy
with
flux,
and
it's
it's
it's
pretty
easy
and
relatively
simple
to
use
I
mentioned
depends
on
earlier,
which
is
a
really
great
feature.
If
you
do
have
things
that
need
to
be
deployed
in
a
certain
order.
A
Helm
integration
is
fantastic
with
flux,
it's
it's
really
it
it's
really
great.
If
you
are
using
helm,
it's
a
natural
extension
that
you
can
just
utilize
with
your
current
helm
deployments.
The
notifications
and
alerting
is
really
simple.
To
use
with
flux
as
well.
Bootstrap,
which
I
will
be
showing
in
my
demo,
is
a
really
easy
way
to
get
started
with
flux,
which
is
a
really
neat
thing,
and
then
that
kind
of
leads
me
to
the
flux
cli,
which
I
think
is
fantastic.
A
I
will
be
showing
it
in
my
demo,
but
I
really
it
is
one
of
my
favorite
clies
that
I've
ever
used,
because
it's
so
user
friendly
and
I
will
be
showing
that
as
well.
A
And
then
these
are
some
things
I
want
to
leave
with.
Before
I
get
to
my
demo,
you
know
to
get
started
with
get
ops,
you
can
try
flux
using
our
getting
started
guide
and
then
we
have
really
great
docs.
You
can
join
our
cncf
slack
community
at
hashtag
flux.
You
can
catch
us
there
if
you
have
any
questions
or
need
any
help
with
anything.
A
You
can
also
sign
up
for
our
mailing
list
for
monthly
updates
announcements
so
on
and
then
you
can
go
star
us
on
github.
You
can
catch
the
the
flux
repository
here
and
you
can
also
join
the
conversation
in
github
discussions.
A
So
I
am
going
to
be
doing
a
brief
walkthrough
of
utilizing
the
fluxialide
to
bootstrap
in
a
cluster
to
set
up
flux
using
bootstrap
is
a
really
quick
and
easy
way
to
get
up
and
running
with
flux,
and
then
I'm
going
to
show
you
how
to
create
a
new
tenant
using
the
cli,
and
basically
this
will
create
you
a
new
name
space,
a
service
account
and
role
binding
and
then
the
last
thing
I'm
going
to
do
is
I'm
going
to
show
you
how
to
create
a
new
source
and
a
customization
sync
to
actually
set
up
continuous
reconciliation
with
a
separate
project
repository.
A
A
However,
I
just
want
to
note
that
flux
can
also
do
hard
tendency
and
there
are
really
great
resources
online
for
that,
but
my
own
personal
experiences,
with
more
limited
to
soft
tendency
where
each
team
was
given
a
name
space
for
their
app
deployments,
and
so,
as
you
can
see
here
on
my
screen,
flux,
the
flux
demo,
repo
does
not
exist
yet,
and
so
we
are
going
to
actually
be
bootstrapping
and
then
that
will
actually
create
that
repo
for
us-
and
I
just
want
to
start
by
saying
that
the
flux
cli
is
a
fantastic
resource.
A
If
you
are
new
to
using
flux,
I'm
going
to
show
you
an
example
of
how
you
can
use
it
if
you're
stuck,
basically,
I'm
just
going
to
run
flux,
bootstrap,
github
dash
h,
and
this
is
going
to
pull
up
the
help
command
and,
as
you
can
see
here
at
the
top,
it
actually
gives
you
a
little
snippet
of
what
the
bootstrap
will
do.
And
in
this
case
it
says
the
blocks.
The
bootstrap
command
creates
the
github
repository.
A
If
it
doesn't
exist
and
then
it
actually
commits
the
toolkit
component
manifest
back
to
the
main
branch
and
then
it
also
configures
the
target
cluster
to
synchronize
with
the
repository.
So
it's
going
to
be
basically
setting
up
flux
to
be
continuously
reconciling
on
itself
and
then
also
if
the
toolkit
components
are
present
on
the
cluster,
the
bootstrap
command
will
perform
an
upgrade
if
needed,
which
is
really
really
neat
and
super
powerful.
A
Because
if
there's
a
new
version
of
flux,
that's
already
been
released,
then
all
you
have
to
do
is
just
rerun
the
bootstrap
command
and
it's
it's
not
disruptive
at
all,
and
it
will
just
actually
update
all
of
those
components
which
is
really
cool,
and
then
it
also
gives
you
some
examples
on
how
to
actually
use
the
command.
So
you
can
really
just
like
copy
and
paste
one
of
these
and
then
just
like
you
know,
add
in
like
the
info.
A
A
So,
as
you
can
see
here,
I
am
running
a
flux,
bootstrap
command
and
what
this
is
telling
it
to
do
is
create
this
flux,
demo
repository
a
private
repository,
and
then
it's
also
telling
it
to
specifically
listen
on
this
path
called
clusters,
my
cluster,
so
it's
not
just
going
to
be
blindly
applying
anything.
That's
in
this
repo,
it's
gonna
be
specifically
applying
things
that
are
within
that
actual
path
and
then,
as
you
can
see
here
on
the
right
side,
you
can
see
that
the
components
are
up
and
running.
A
So
these
are
the
different
controllers
that
I
mentioned
earlier.
If
you
do
notice
here,
though,
there
are
a
couple
of
controllers
missing,
so
bootstrapping
actually
doesn't
come
with
the
image
controllers
by
default.
If
you
do
want
it,
there
is
an
additional
flag.
You
can
add
on
after
you've
bootstrapped,
you
can
run
the
bootstrap
command
again
with
that
additional
flag,
and
it
will
also
create
those
image
controllers
as
well
for
you
but
yeah.
A
So
we
can
see
that
there's
this
customization.yaml
in
here
and
I
just
want
to
reiterate,
I
know,
there's
a
lot
of
confusion
with
the
names,
but
this
is
what
I
was
talking
about
earlier
when
I
mentioned
a
kubernetes
customization,
so
this
yaml
obviously
tells
it
to
apply
these
resources,
and,
like
I
mentioned
earlier,
the
customization
controller
is
so
named
because
it
in
the
background,
actually
creates
this
yaml
as
well.
A
If
it's
not
already
there,
but
if,
for
some
reason
you
want
to
limit
the
resources
or
you
want
to
add
patching
or
things
like
that,
you
can
still
utilize
kubernetes
customization
as
well.
It
will
work
with
your
current
setup
if
you
are
utilizing
customization
already,
but
as
you
can
see
here,
there
are
two
resources
that
we
are
telling
it
to
apply:
the
geotk
components.yaml
and
the
gotk
sync.
A
So
the
gotk
components
yemo
actually
creates
the
flux
system
namespace,
as
you
can
see,
and
then
it
also
creates
custom
resource
definitions
that
are
necessary
for
flux
to
work
along
with
in
this
file.
You'll
also
find
all
of
the
components
the
controllers
all
declared
in
here
as
well.
So
this
is
where
all
of
those
are
stood
up
and
then
the
geotk
sync
yaml
actually
has
our
source
and
our
customize
that
are
created.
So
the
first
one
you
see
here
is
the
get
repository
source
and
it's
actually
pointing
to
this.
A
This
repo
that
we're
already
currently
in
so
that
flex,
demo
repo
and
it
is
telling
it
to
listen
on
a
one
minute
interval
and
so
that
what
that
means
is
every
minute.
This
source
controller
will
actually
come
check.
This
repository
and
pull
in
those
artifacts,
and
then
here
you
can
also
see
this
customization,
which
is
actually
pointing
back
to
that
same
source
rep
that
was
just
created
above
and
then
it
is
specifically
pulling
in
this
case
on
a
10
minute
interval.
A
A
And
then,
if
we
go
back,
I
am
going
to
actually
clone
that
repo
so
that
we
can
actually
add
a
new
tenant
and
push
the
changes
to
that
repo
and
so
we're
gonna
change
into
that.
A
And
then
so,
this
is
actually
that
additional
repo
that
I
was
talking
about
that
project
repo.
It's
very
simple
application
that
we
like
to
use
for
our
examples.
It's
just
a
ui,
that's
going
to
be
created.
It
has
a
little
simple
back
end
of
front
end
and
it's
just
a
few
yamls
in
each
and
so
we're
going
to
be
creating
basically
a
tenant.
A
That's
then
going
to
have
a
sink
pointing
to
that
repo
that
additional
repo
so
now
we're
going
to
create
the
tenant
and
we're
going
to
use
the
flux
cli
to
do
so.
You
can
also
there's
there's
two
ways
to
do
this.
You
could
yeah
so
first
we're
actually
going
to
create
the
directory
for
this
new
tenant
to
live
in
to
be
pushed
into,
and
then
we're
going
to
run
this
flex
create
tenant
command.
A
So
I've
added
this
dash
dash
export
command
so
that
it
will
actually
export
it
into
this
rbac.yaml.
But
if
you
left
that
out,
it
would
actually
create
the
tenant.
But
again
we
want
to
do
everything
declaratively,
so
we
want
to
actually
push
this
up.
So
what
this
is
doing
is
it
creates
that
namespace
and
then
it
creates
this
service
account
called
test
and
then,
along
with
that,
it
creates
this
role
binding.
That
then
binds
the
service
account
and
the
cluster
role
to
this.
A
To
the
needed,
I
mean
sorry,
the
user,
reconciler
and
the
service
account
test
to
this
needed
cluster
rule.
So
now
we
are
going
to
actually
push
this
up
to
the
flux
demo,
repo
in
that
new
folder
that
we
just
created
called
test.
A
And
so,
if
we
go
back
and
look
at
that
repo,
we
will
be
able
to
see
that
in
there
now
so
yeah,
as
you
can
see
now,
there's
a
test
with
that,
our
back
file
that
we
just
created.
A
So
now
we
have
to
go
tell
because
the
sync
interval
that
we
set
on
this
one
is
10
minutes.
So
the
customization
controller
is
going
to
take
10
minutes
to
actually
pick
this
up
on
its
own,
we're
going
to
take
advantage
of
something
called
flux
reconcile.
A
So
this
is
actually
going
to
tell
the
the
controllers
to
actually
go
pull
it,
and
so
one
key
thing
here
is
that
you
could
actually
have
run
flux,
reconcile
source
git
and
the
flux
system
itself
first
and
then
run
the
flux,
reconcile
ks
flux
system,
but
adding
that
flux,
reconcile
ks
flux
system
and
then
that
flag,
dash
dash
with
source
actually
bypasses
the
need
for
that
it
basically
first
reconciles
the
source
and
then
the
customization.
So
I
really
love
that
command.
A
It's
just
something
I
wanted
to
point
out
makes
life
a
little
easier,
because
then
you
have
to
wait
for
two
commands
and
then,
as
you
can
see
here
when
I,
when
I
run
cube
control,
get
namespace,
you
can
actually
see
that
now
the
test
namespace
has
been
created
as
of
17
seconds
ago,
which
is
awesome.
So
when
that
was
reconciled,
it
did
stand
up
the
new
name
space
for
us
and
then
now
we
are
going
to
actually
create
yeah.
A
So,
as
you
can
see
here,
the
two
the
commit
actually
does
match
up
with
the
one
that
is
in
there.
A
So
that's
a
good
way
to
actually
check
that
like
if
something,
if
you
notice
something's,
not
you
know
in
there,
then
you
can
check
with
the
last
commit
that
was
pulled
by
it
was
so
now
we
are
going
to
set
up
a
sync
for
that
pod
info,
deploy
app,
so
we're
going
to
set
up
a
source
and
then
a
customization
as
well
to
actually
listen
to
that
other
repo
so
that
we
can
deploy
that
application
in
our
new
test
tenant.
A
A
Let's,
let's
make
sure
it's
been
pushed
there,
it
is
our
sync.yaml
with
everything
that
we
told
it
to
do,
and
so
now
we're
gonna
again,
because
that
interval
is
a
10
minute.
Sync,
we
are
going
to
go
in
and
actually
run
that
reconcile
command
again
to
get
it
to
speed
things
up,
and
once
we
do
that,
we
should
be
able
to
see
that
that
the
the
changes
are
made.
A
So
now
we
can
actually
do
a
flux,
get
source
get
and
then
the
dash
a
flag
is
to
get
all
the
sources
that
are
out
there,
and
we
can
see
that
now
there
is
a
test
in
in
the
test
name
space.
There
is
a
new
source
called
pod
info
and
same
thing
with
the
customization.
We
can
see
that
now
there
is
a
customization
and
we
can
also
see
that
it
successfully
applied
if
it
was
unsuccessful.
A
We'd
see
an
error
message
where
the
message
is,
and
so
now
we
can
actually
go
get
the
pods
and
test,
and
we
can
see
that
both
are
up
and
running
just
like
that.
Customization
message
told
us
that
it
was
applied,
and
so
after
this
we
can
actually
port
forward
it
and
make
sure
that
the
app
was
successfully
deployed.
A
Which
it
was
and
then
now
basically
we're
going
to
just
make
a
little
tweak
to
the
the
pod
info,
deploy
app
so
that
we
can
actually
see
flux
in
action,
pick
up
a
change
and
actually
apply
it,
and
so
I've
already
cloned
that
repo
and
we're
just
going
to
make
a
small
change
in
the
ui
color.
So
you
can
see
here,
there's
an
environment
variable
that
controls
that
pod
info
ui
color
and
we're
just
going
to
change
that
value
and
we'll
push
this
change.
A
And
once
this
is
pushed
then
we'll.
Let
flux
actually
pick
it
up
and
make
that
actually
restart
the
pod.
With
those
changes.
A
So
now,
if
we
give
it
a
little
bit,
I'm
actually
because
this
customization
only
had
a
one
minute
interval.
We
can
actually
wait
for
it
and
let
it
do
its
thing
and,
as
you
can
see,
it's
already
recreated
the
container
and
it
is
almost
up
and
running
just
give
it
another
second
yeah
there.
It
is
so
it's
already
restarted
it
on
its
own.
We
didn't
do
a
record
style
in
this
case,
but
it
did
it
on
its
own
and
then,
if
we
give
it
a
second.
A
I
did
have
to
actually
restart
the
port
forwarding,
so
that
was
on
me
and
then
yeah
there.
It
is
so
the
background
has
been
changed
to
the
color
that
we
told
it
to
so
that
did
it
all
on
its
own.
That's
the
magic
of
flux.
That's
what
makes
it
really
amazing
is
that
it
just
like
continuously
is
picking
up
those
changes
and
then
what
happens
when
a
bad
actor
comes
along
and
actually
makes
a
change
that
you
didn't
want
them
to.
A
So
if
someone
comes
along
and
makes
a
manual
change
or
something
happens
and
configuration
drift
does
happen,
so
what
you
actually
desired
is
suddenly
not
the
state
that's
out
there
it
will.
A
It
will
take
care
of
you
in
that
case
too,
so
I'm
going
to
show
you
that
by
actually
deleting
the
deployment
for
the
front
end,
I'm
going
to
completely
delete
it
manually
by
running
a
cube,
control,
delete,
and
so
once
I
do
that,
you'll
see
that
flux
will
actually
reapply
it
so
running
a
cube
control
delete
deployment,
it
is
gone,
you
can
see
it's
terminating
and
then
I'm
actually
going
to
reconcile
it
in
this
case.
A
So
we
don't
have
to
wait
that
minute
and
there
you
can
see
it's
already
back
up
and
running.
It's
already
standing
itself
back
up
and
if
we
give
it
another
second,
it
will
be
successfully
running,
and
that
is
really
the
the
main
things
I
just
wanted
to
hit
on
and
yeah
it's
it's
that
those
were
the
features.
I
really
wanted
to
show
and
there's
so
much
more
that
flux
can
do,
but
this
was
just
a
little
taste
of
the
the
real
cool
features
of
plugs.
A
So
so
that
wraps
up
the
demo
portion,
where
I
showed
you
how
to
get
started
with
bootstrap
and
how
easy
it
is
to
get
started
with
flux
with
that
and
then
also
how
to
create
a
tenant
and
then
how
to
create
a
source
and
customization
to
point
to
a
different
repo,
and
I
really
hope
that
this
was
an
informative
demo
and
it
really
showed
you
how
truly
easy
it
is
to
get
started
using
flux.