►
From YouTube: Flux for Helm Users
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
Hi
everyone,
so
this
is
the
top
get
ops
for
helm
users.
I
am
scott
rigby,
I'm
on
the
dev
experience
team
at
weedworks,
I'm
involved
in
various
cncf
things,
including
co-chairing
the
get
ops
working
group.
I
also
co-maintain
cncf
projects,
including
helm,
flux
and
open
githubs.
A
So
that's
why
I'm
giving
this
talk
on
using
flux
to
implement
get
outs
for
home
users
today,
here's
my
twitter,
twitter,
here's
my
twitter
handle
r6by,
I'm
also
scott
on
all
of
the
slacks
and
also
scott
rigble.
One
word
in
github
so
feel
free
to
reach
out
to
me
in
any
ways
about
open
source
projects
or
other
things
related
to
cncf,
get
ops,
flops
or
helm
so
quickly.
What
to
expect!
I
am
going
to
clarify
the
intended
audience
for
this
talk.
Just
so.
You
know
you're
in
the
right
place.
A
A
I'll
give
a
few
notes
on
comfort
levels
around
migrating
from
the
helm
cli,
whether
in
event,
driven
ci
or
used
manually,
to
get
ops
in
continuous
and
progressive
delivery.
Then,
finally,
we'll
end
with
a
demo
showing
you
how
flux
makes
it
really
easy
to
do.
Just
that.
A
A
This
talk
is
definitely
for
you,
so
I've
met
a
lot
of
you
over
the
years
in
the
helm
community
on
the
kubernetes,
helm
and
charts
slack
channels
in
weekly,
helm,
dev
meetings,
irl
at
conferences,
a
lot
of
you
and
through
github
and
in
the
twitter,
verse
generally
etc.
So
I'm
really
looking
forward
to
following
up
on
your
questions.
After
this
talk
with
you-
and
I
meant
what
I
said
about
reaching
out
on
these
topics,
so.
A
Okay,
so
the
brief
context
for
new
users-
you
probably
you're-
probably
watching
this,
because
you
have
some
interest-
or
at
least
curiosity
in
these
topics,
but
I'm
not
going
to
assume
any
specific
knowledge
about
git,
ops
or
flux
or
or
help
in
fact,
but
that'll
be
the
quickest
one.
So
we'll
start
with
a
short
intro
to
all
of
these
to
be
welcoming
to
to
all
helm
users
and
to
level
sets,
so
everyone
can
follow
along
and
then
we'll
get
right
into
the
meat
of
more
season.
10
users
are
looking
for.
A
So
what
is
helm?
It
is
a
widely
adopted
package
manager
for
finding
sharing
and
deploying
apps
on
kubernetes
in
the
context
of
helm,
you're
going
to
hear
terms
like
charts
releases
revisions,
if
you're
not
sure
what
those
are.
Here's.
A
super,
quick
intro,
so
helm,
similar
to
apt
or
yum
for
linux
helm
manages
packages
for
kubernetes
called
charts.
A
When
so,
these
application
definitions
can
be
deployed
to
a
cluster
as
a
set
along
with
user-specified
configs
things
that
you
specify
for
how
the
application
is
supposed
to
behave
in
kubernetes
or
just
behave
on
its
own.
A
So
the
deployed
kubernetes
objects
and
these
those
user-defined
configuration
values
together
are
called
releases
releases
also
have
revisions
that
that's
important
to
know
just
because
when
we
talk
about
rollbacks
users
can
roll
back
to
previous
revisions
if
needed
for
a
reason.
A
So,
if
you
don't
know
you,
you
probably
do,
but,
but
it's
just
important
to
say
that
helm
charts
are
when
I
say
it's
a
widely
adopted
package
manager,
it's
very
wildly
popular
and
it's
a
big
way
that
many
people
get
introduced
to
kubernetes,
because
it
helps
to
simplify
some
of
the
complexity.
A
Around
kubernetes
resources
and
people
are
often
not
only
interested
in
infrastructure
they're
interested
in
what
they
can
do
with
it,
and
that
usually
includes
apps.
So
helm
charts
exists
for
most
applications
that
can
be
run
on
kubernetes.
There
are
nearly
7
000
of
them.
7000
charts
to
choose
from
on
the
cncf
artifact
hub,
so
go
check
that
out.
That's
at
artifacthub.io.
A
So,
in
order
to
guide
you
through
the
benefits
that
flux
brings
to
helm,
I'm
going
to
briefly
note
some
things
that
are
in
and
out
of
scope
for
helm
by
design.
A
This
is
important
to
note
so
that
you
know
which
tool
the
select
and
why
you
would
even
need
something
to
extend
so
helm
is
a
client
and
sdk
only
that
was
by
design
for
home
free,
which
has
been
around
for
several
years
now.
A
Sli
direct
that
sdk
is
meant
to
to
provide
the
internal
functionality
of
helm
so
that
other
tools,
extending
it
don't
have
to
be
constricted
by
the
limits
of
the
cli.
It's
output,
exact,
it's
specific
output,
it's
things
that
are
that
are
that
are
meant
to
be
used
for
cli.
Only
those
internal
functions
that
powers,
the
cli
can
then
be
mixed
in
in
other,
can
be
used
in
other
ways.
So
here
are
some
of
the
things
that
are
designed
to
be
out
of
scope
for
help.
A
One
of
the
big
ones
is
crd
upgrades.
This
is
a
long
asked
for
feature
that
is
explicitly
outside
of
the
scope
of
helm.
There's
a
dedicated
page
to
this
in
the
helm,
docs,
it's
not
just
because
we
don't
want
to
do
it.
It's
because
there
are.
There
are
very
good
reasons
why
you,
you
wouldn't
want
this
to
be
inside
of
this
in
the
scope
of
a
cli
tool.
A
So
please
read
that
if
you're
interested,
I
don't
want
to
spend
too
much
time
on
that
here,
but
that
is
something
that
users
of
charts
that
that
update
crds
care
about.
So
what
other
things?
Just
brief
briefly
listed
that
are
out
of
scope.
You
can
read
this
on
the
slide,
but
I'll
just
note
them
real,
quick,
managing
or
structuring
multiple
environments.
A
So
that's
most
people
use
scripting
for
that
of
some
kind
or
some
kind
of
tool
to
help
do
that.
Helm
file
has
been
a
popular
one
over
the
years
and
there
are
now
others
to
do
this,
including
flux.
A
So
any
kind
of
control,
loop
or
retry
logic
outside
of
just
under
the
hood
functionality
for
short
for
short
functional
retries,
are
outside
of
the
scope
of
client,
because
it
is,
it
is
a
cli.
It's
meant
for
attended
operations.
A
A
So
or
any
other
kind
of
controller
functionality
has
to
come,
it
has
to
be
outside
of
that
scope,
any
kind
of
automated
responses
beyond
beyond
automated
rollback,
which
is
an
amazing
feature
of
helm
by
the
way,
automated
drift
detection.
This
is
definitely
outside
of
the
scope.
A
So,
imperatively,
you
can
do
this
with
the
helm,
diff
plugin
in
some
way,
and
that
is
a
wonderful
tool,
but
anything
else
around
automated
detection
of
differences
as
outside
of
the
scope,
so
brief,
intro
to
gitops,
and
then
I'm
gonna
do
a
brief
intro
to
flux
and
we'll
give
you
the
benefits
and
we'll
give
you
the
demo
so
get.
Ops
is
a
set
of
principles
for
operating
and
managing
software
systems.
A
These
principles
are
derived
from
modern
software
operations,
but
they're
also
rooted
in
pre-existing
and
widely
adopted
best
practices.
So
this
is
not
a
brand
new
thing
at
all.
It
is
just
a
a
a
current
iteration
of
of
of
knowledge.
That's
been
around
for
a
long
time,
just
put
together
in
a
way
that
that
is
now
becoming
very
so.
The
desired
state
of
the
github's
managed
system
must
be
declarative,
versioned
and
immutable
pulled
automatically
and
continuously
reconciled.
A
Those
are
the
four
principles,
so
a
quick
note
about
what
we
mean
by
declarative
in
principle,
one
because
you
may
not
know
this
so
declarative
and
imperative
are-
are
generally
they're,
two
different
things
so
with
declarative
management,
you
declare
the
system
that
you
you
declare
to
the
system.
What
you
want
the
end
state
to
look
like,
so
the
system
then
works
to
make
this
reality.
Usually
reports
on
the
status
on
the
progress
of
making
that
happen.
It's
making
that
declared
state
of
reality
in
the
end
over
time.
A
Two
is
where
the
get
in
get
ops
comes
from,
although
any
system
that
fits
the
criteria
defined
by
this
principle
can
be
used,
any
other
version,
control
or
or
any
other
storage
system
that
that
that
has
that
that
has
these
criteria
principle
three
is
what
differentiates
get
ops
from
event-driven
ci
jobs
triggered
by
changes
in
git.
A
Here,
the
desired
state
is
pulled
by
the
system
whenever
it's
needed
by
the
system
for
any
reason,
without
the
need
to
be
triggered
by
some
kind
of
action
on
the
source
repository
or
something
like
that
and
principle.
Four
is
where
software
agents
are
always
assessing
the
actual
system,
state
and
they're
working
to
bring
it
closer
to
your
desired
state
that
you
declared
in
your
version
control.
So
that's
it
that's
notes.
I
didn't
mention
kubernetes
at
all.
A
A
So
so
that's
that's
the
brief
venture
to
get
ups.
Briefventure
flux.
Is
this:
it's
a
cnci
incubating
project.
A
We
call
it
the
flux
family
of
projects,
because
it's
a
set
of
continuous
and
progressive
delivery
solutions
from
git
to
kubernetes.
This
includes
the
flux,
cli
git,
ops
toolkit,
which
is
a
set
of
controllers
and
go
packages
that
I'll
show
you
a
brief
diagram
of
next,
and
it
includes
flagger
a
progressive
delivery
tool.
That's
that's
that
can
be
used
on
its
own
at
this
point,
but
it's
also
built
heavily
built
with
git
ops
in
mind
and
built
to
to
work
with
get
ops.
A
A
Flux
is
some
of
the
benefits.
Are
flux?
Is
the
only
cd
tool,
continuous
delivery
tool
that
I
know
of
anyway
that
may
change,
but
that
purely
uses,
helm's
sdk,
there's
no
shelling
out
to
a
binary,
and
it
also
doesn't
fork
to
it-
doesn't
fork
helm
in
order
to
do
that
either.
So
this
allows
flux
to
be
very
flexible
and
powerful
to
do
many
things,
while
maintaining
a
solid
architecture
and
also
a
low
memory
footprint
in
your
cluster
and
because
we're
big
sdk
users,
the
helmets
decay.
A
It
means
we
contribute
to
helm
upstream
quite
a
bit,
so
everyone
gets.
Everyone
gets
the
benefits,
not
just
flux,
so
you
know
benefits
of
open
source.
A
Some
of
the
other
really
important
things
to
note
are
flux's
health
controller
manages
crd
upgrades.
So
when
I
said
that
was
out
of
scope
of
hell
for
helm,
I
focused
on
that
because
it's
not
out
of
the
scope
for
the
flexsound
controller,
and
that
is
huge
news.
So,
while
helm
cli
has
an
initial
installation
support
for
sorry
support
for
initial
installation
of
crds
that
are
required
for
the
other
resources
in
your
chart,
it
doesn't
handle
upgrades
and
that's,
as
I
said
before,
by
design
so
normally.
A
This
is
a
manual
step
for
charts
that
install
apps,
which
update
their
crds
periodically,
for
example,
think
cert
manager,
and
there
are
other
charts
that
are
widely
that
are
very
popular
this.
A
So
the
helm
controller
allows
you
to
do
this
out
of
the
box
in
an
unattended
way,
and
it's
got
options
to
let
you
fine-tune
this
automated
process
as
you
need
timeouts
and
other
things.
So
it's
that's.
That's
a
huge
benefit.
The
helm
controller
also
includes
a
depends
on
feature
that
allows
you
to
manage.
A
A
So
this
also
saves
a
bit
of
memory,
because
umbrella
charts
store
all
of
that
information
in
memory.
In
order
to
do
what
it
does.
So,
that's
very,
very
helpful.
It
depends
on
feature,
so
flux
also
makes
it
easy
to
manage
multiple,
multiple
environments
for
home.
It's
it's
built
on
controller
runtime,
kubernetes
support
controller
runtime,
so
it
includes
control
loop,
another
retry
logic
out
of
the
box,
which
can
be
extended
as
well.
A
It
gives
feedback
on
how
automating
your
home
release
is
going
through
the
flex
notification
controller.
I'll
show
you
in
a
second-
and
it
includes
automated
drift
detection.
That's
one
of
its
big
features.
So
when
the
resources
in
the
cluster
that
are
defined
by
your
chart
diverge
from
your
desired
state
that
you
specified
in
your
chart
and
your
configs,
it
will
notify
you
on
divergence
or
whenever
anything
was
wrong.
A
So
here
are
some
things
that
flux
does.
In
short,
I'm
not
going
to
go
over
them
now.
Just
please
take
a
look
at
the
slide,
and
these
are
also
on
the
home
page
of
the
flux
website.
A
Flexcb.Io
just
note
things
like
flux
does
support
multi-tenancy
at
a
multi-cluster,
multiple
git
repos
it
integrates
with,
with
with
with
existing
tools,
with
almost
all
popular
tools
for
for
working
with
kubernetes,
and
you
know
just
just
take
a
look
at
some
of
these
points
and
there's
a
lot
of
information
about
other
reasons
why
flux
is
useful
and
that
you
may
want
it
anyway
on
the
flux
website.
A
So
in
short,
floss
is
a
set
of
specialized
controllers
that
rely
on
each
other
to
do
a
specific
job.
Here's
just
a
very
it's,
not
an
architectural
diagram,
but
it's
a
it's
a
short.
It's
a
brief
slide,
showing
you
what
the
different
controllers
do
I'll
just
list
them
real
fast,
so
the
source
controller
watches
your
defined
sources
where
you
specify
your
your
desired
state.
A
So
when
you
put
your
home
charts
in
git
and
your
other
yaml
files
and
git,
the
source
controller
brings
any
of
those
changes
that
you
make
into
the
cluster
so
that
these
other
controllers
can
act
on
those
it
does
that
very
well,
so
the
desired
state
can
be
in
a
variety
of
popular
formats.
It
can
be
inflaming,
ammo,
customization
or
helm,
charts,
there's
even
a
newer
terraform
controller,
a
flex,
terraform
controller
that
lets.
A
You
store
your
desired
state
in
that
format,
and
I
expect
more
controllers
to
support
other
formats
to
come
soon
or
as
we
as
we
go
as
as
as
needed
by
the
community.
So
the
customized
controller.
Next
one.
The
list
gets
your
changes
from
from
the
source
controller,
because
that
already
brought
them
into
your
cluster
right
and
it
applies
those
both
the
plain
yellow,
as
well
as
any
optional
customized
overlays
to
the
cube
api.
A
It's
it's
basically
applying
that
information
from
your
source
to
the
controller.
It's
actually
doing
the
reconciling
of
that
in
the
cube
api,
so
the
yaml
files
also
include
kubernetes
resources.
A
Well,
they
include
kubernetes
resources,
but
they
also
include
custom
resources
that
other
controllers,
such
as
help
such
as
helm,
rely
on
to
do
their
job.
A
So
that's
really
an
important
thing
to
note,
because
some
people,
when
they
install
flips,
wonder
why,
if
they're
doing
installing
it
primarily
for
help
wonder
why
they're
using
the
customized
controller
as
well,
when
they
don't
use
customize
as
a
tool
in
their
workflows,
you
don't
specifically
have
to
use
customizes
tool.
Your
workflows
customize
is
just
built
into
cube
control,
and
so
it's
built
into
the
libraries
as
well,
so
that
controller
was
made
to
handle
both
plain
yaml
and
any
additional
customized
overlays
that
you
might
be
using
on
top
of
those.
A
So
once
the
helm,
repo
and
home
release
crds
are
applied
to
the
cube
api,
but
by
the
customized
controller
or,
however,
you
decide
to
get
them
in
there.
If
you,
you
want
to
get
them
in
there
in
your
own
way,
the
helm
controller
uses
that
information,
those
crds
in
the
cube
api
to
automate
when
your
home
releases,
you
then
and
I'll
I'll.
A
Tell
you
a
little
bit
more
about
this
as
we
go
through
the
demo,
but
notification
controller
keeps
you
posted
about
how
things
are
going
and
it
notifies
you
of
any
problem
with
divergence.
As
I
mentioned,
that's
what
it
does.
That's
the
notification
controller
is
what
handles
that
side
for
flux
it
can
post
to
slack.
It
can
post
to
many
different
team.
A
Tools
that
you
need
for
notifications
and
finally,
the
image
automation
controllers
handle
writing
the
exact
image
versions
back
to
your
git
source
if
your
desired
state.
If,
when
you
declare
what
you
want
for
your
images
in
your
desired
state
as
a
simver
range
or
a
similar
constraint,
that's
really
helpful.
If
say
you
just
want
to.
You
want
images
that
are
any
minor
or
patch
versions
of
a
specific
image
to
be
updated
automatically,
because
you
trust
that's
that
source.
A
But
you
want
to
open
a
pr,
have
an
automatic
pr
open
for,
for
whenever
there
is
a
a
new
major
version
or
something
like
that,
there's
you
can
specify
your
own
rules
and
your
own
constraints,
but
this
is
essentially
version
pinning
for
git
ops
so
about
home
controller
in
the
middle
there.
You
know
I'm
experiencing
help
myself
as
a
user
and
contributor
and
maintainer,
and
I
wanted
to
contribute
to
flux
a
few
years
ago,
because
I
was
very
interested
in
git
ups
and
after
researching
what
was
available.
A
I
found
the
helm
controller
would
be
for
me
anyway.
The
most
stable,
powerful,
get
ops
tool
for
the
wider
helm
ecosystem.
So
I
wanted
to
put
my
efforts
there.
There
are
other
tools
and
there
are
many
good
ones
and
I'm
hoping
that
we'll
continue
to
work
for
more
interoperability
between
those
in
the
future.
A
But
in
short,
the
helm
controller
is
built
on
kubernetes
core
controller
runtime,
like
I
said
before.
So
that
means
anyone
with
kubernetes
knowledge
can
contribute
your.
You
may
be
here
listening
this
talk
as
a
user,
but
you
may
be
interested
in
contributing,
so
just
keep
that
in
mind
that
it
is
made
not
to
be
a
special
snowflake
but
to
to
follow
best
practices
and
be
very
open
to
contributions.
A
So,
let's,
let's
take
a
very
quick
look
at
the
architecture,
diagram
of
how
these
controllers
work
together
to
manage
home
releases
and
then
we'll
just
move
right
on
so
here
here's
here's
something
that
you
see
on
the
flux
cd
website.
If
you
go
to
the
helm,
the
components
home
controller
you'll
see
this
diagram.
A
So
a
very
short
description
is
when
running
flux,
bootstrap,
which
is
optional,
but
it
is
the
easiest
way
that
sets
up
a
git
repo
for
you.
If
one
doesn't
already
exist,
it
installs
flux,
components
in
your
cluster
and
mirrors
those
mirrors.
Those
manifests
for
you
into
your
git
repo,
so
you
can
see
exactly
what's
going
on.
A
It
it
imperatively,
adds
custom
resources,
telling
the
source
controller
to
watch
your
git
repo
and
it
mirrors
those
manifests
in
your
git
repo
as
well
and
from
this
point
on
the
customized
controllers
I
mentioned
before
periodically
works
to
reconcile
those
all
those
manifests
with
the
resources
running
your
cluster.
So
so,
while
you
have
to
bootstrap
flux
for
it
to
actually
do
its
get
ops
magic
once
those
controllers
are
running
you,
the
the
the
customized
controller
will
actually
be
reading.
A
Your
manifests,
including
the
manifest
for
the
flux,
control
for
flux
itself,
so
you
can,
from
that
point
on
really
be
doing
git
ops
and
you
can
use
the
bootstrap
command
to
even
update
your
your
flux,
installation,
your
or
any
of
your
other
tool,
including
the
the
flux
components
themselves.
A
So
that's
that's
one
of
the
design,
that's
one
of
the
features
of
its
design
that
I
think
is
really
excellent,
that
you're
doing
good
ops
really
right
out
of
the
gate,
so
the
helm
controller
sinks,
the
home
controller,
as
I
mentioned
since
the
hell,
repo
and
home
release,
custom
resources
which
I'll
show
you
in
a
moment
and
use
the
helm
sdk
to
do
all
the
helm.
Things
you're
already
used
to
that's
kind
of
the
summary
of
this
slide
for
home
users.
A
So,
okay,
so
the
benefits
ensure
are
you
know:
flux
introduces
an
additional
layer
of
reliability,
consistency,
observability
and
audibility
to
the
benefits
of
using
helm,
cli
or
for
that
manually
or
nci.
So.
A
On
comfortability
levels
and
kind
of
like
just
what
you
need
to
do
to
move
from
the
helm
cli
to
the
helm
controller
right
before
I
show
you
a
demo
of
doing
exactly.
That
is
that
it
all
starts
with
using
problem
declaratively.
A
So
you
may
want
to
look
at
this
cncf
blog
post
that
was
just
published
by
tomo
nakahara,
the
vp
of
of
dx
at
weworks,
on
how
flux
lets
you
use
helm,
declaratively,
there's
there's
a
link
to
it
in
the
in
the
slide
deck
that
we'll
provide
to
you
later
and-
and
just
please
check
that
out.
It's
a
very
good
write-up
of
how
that
works.
A
A
So
flux
has
a
format
for
you
to
do
that
for
help
so
for
for
helm,
ci,
automation,
users.
A
This
is
mainly
just
think
of
this
as
a
process
of
decoupling,
your
ci
and
your
cd,
so
and
for
any
helm
users,
whether
you
already
have
ci
in
place
or
whether
you're
just
starting
from
scratch,
helm
releases
through
flux,
are
properly
separated
into
continuous
delivery
for
you
already
just
by
using
the
tool.
A
So
just
a
quick
note
on
comfortability
that
change
can
be
scary
for
various
people,
but
I
assume
that
you're
here,
because
you
you,
you
want
that
change,
and
you
know
it's
necessary.
A
So
here's
a
few
list
of
tips
to
to
help
to
help
convince
those
that
you
need
to
to
to
share
account
to
share
ownership
and
to
share
the
risk
ultimately
of
making
that
change.
A
There's
there's
a
lot
of
good
resources
on
the
flux
cd
website
about
this,
how
to
convince
who
needs
to
be
convinced
and
just
know
that
there
are.
There
are
organizations,
mature
organizations
and
risk-averse
ones
that
are
large,
small,
old
and
even
new
ones
that
are
they're,
adopting
get-ups
so
and
they're
using
flux.
So
so
that
is
also
fuel
for
you
to
help
make
your
case
and
if
you
need
to
defer
to
additional
experts
to
help
with
that,
there
are
many
people
in
the
community
through.
A
You
can
find
us
on
slack,
as
I
said
before,
on
the
various
the
various
ways
to
do
that
in
the
cncf
flux,
channel
and
in
other
channels
on
slack
and
if
you
have
a
if
you're
in
a
business.
That
is
that
cannot
be
talking
publicly
about
what
you
need.
There
are
vendors.
There
are
people
who
who
can
help
for
paid
pri
in
a
paid
way.
So
if
you
go
to
the
flock
cd
website,
the
support
page
has
a
section
called.
A
My
employer
needs
additional
help
and
it
lists
people
who
provide
paid
support
and,
if
you're,
also,
if
you're
in
a
company
that
does
provide
paid,
support
and
you're
not
on
that
list.
Let
us
know-
and
we
will
add
you
or
just
make
a
pull
request
and
add
yourself.
A
So
all
right,
it's
demo
time
and
I
am
now
going
to
stop
sharing
these
slides
and
instead
share
a
and
then
share
a
gist
that
I
made
and
a
terminal
and
we'll
go
through
this
really
quickly,
so
that
you
can
see
how
easy
it
is
to
to
move
from
helm
releases
managed
with
the
cli
to
to
manage
with
get
ops.
A
A
Okay,
so
so
I
have
gone
ahead
and
started
this
process
you
don't
have
to
so
you
don't
have
to
wait
for
it
to
happen,
but
I
haven't.
I
haven't,
created
I'm
starting
from
scratch
here.
So
there's
nothing
special,
except
for
I've.
I've
saved
55
seconds,
creating
a
kind
cluster,
but
just
there
there
are.
There
are
some
instructions
for
users
on
mac
or
linux
to
use
homebrew.
If
you
want
to
you
can
install
flux
and
kind
any
other
way.
You
can
also
do
this
demo
on
a
cluster.
A
That's
not
a
kind
cluster.
I
just
recommend
this
because
anyone
can
do
it
without
even
having
a
cloud
account
to
that
or
pay
for
a
kubernetes
kubernetes
instance
to
demo
them
on
for
themselves,
and
it's
cross
system
compatible.
So
this
should
work
out.
Fine,
regardless
of
the
system
you're
on
my
gist
is
in
is
in
shell
or
bashed,
so
or
rather
just
shell,
so
so
it
should
be
posits
compliant
if
you
find
a
plug
in
that
I'm
using
bash.
A
If
you
find
a
bug
in
that
in
another
shell,
let
me
know,
but
this
should
get
you
on
your
way
and
at
least
helped
you
there
so
just
make
sure
that
you
have
the
most
updated
versions.
I
I
do
and
make
sure
that
you
have
a
personal
access.
Token
that's
exported
into
your
your
cli.
The
personal
assets,
token
have
a
real
scope.
I
have
that
just
know
that.
A
This
is
handled
from
a
security
point
of
view.
Don't
be
scared
when
you
hear
that,
because
you
know
that
gives
any
tool
access
to
all
of
your
repos
in
in
github,
if
you're
using
github
like
I
am
in
this
demo,
but
don't
fear
that
is
not
passed
in
any
way
to
any
of
the
automated
controllers
or
to
your
cluster
at
all.
So
don't
be
scared.
It's
only
used
within
the
context
of
your
cli
session.
A
A
So
I'm
just
going
to
show
you
that
I
have
my
and
know
myself
that
I
have
my
github
token
set.
That
is
the
length
for
that.
I
expect
to
see.
For
a
github
token,
I've
created
a
kind
cluster,
and
now
I'm
going
to
do
a
flux,
bootstrap
command,
so
I'll
just
paste
it
here.
So
that's
starting
while
we're,
while
I'm
explaining
it.
A
The
output
itself
explains
this,
but
just
to
be
clear
on
some
of
these
settings
that
I
made
I
I
wanted
this
to
be
in
my
personal
github,
so
it's
under
my
scott
rigby
github
username.
I
set
the
interval
to
10
seconds,
which
is
unusual
for
for
an
installation.
That's
for
a
flux,
installation,
that's
not
a
demo,
I'm
doing
that
so
that
for
demo
purposes,
we'll
never
have
to
wait
for
more
than
10
seconds
and
half
the
time
I'll
have
to
wait
for
less
than
that.
A
Generally,
you
might
want
to
set
this
to
something.
I
think
the
default
is
one
minute
and
you
may
want
to
set
this
to
something
like
five
or
ten
minutes,
depending
on
your
setup
that
that
can
be
covered
and
is
covered
in
separate
demos,
but
just
know
that
when
I
gave
a
path
that
creates
the
structure
for
where
flux
flux
writes
those
manifests
in
your
get
repo,
as
I
mentioned
before,
and
there's
no
gold
standard
for
that,
there's
no
specific
way
that
that
needs
to
be
done.
A
Flux
is
completely
unopinionated
about
that
and
is
made
to
be
very
flexible
in
that
way.
That
said,
there
are
some
good
practices
that
are
covered
in
other
talks
and
for
now
I'm
just
doing
a
very
basic
one
at
a
path
called
clusters,
dev,
where
you
may
also
have
a
folder
clusters
stage,
clusters
prod,
etc.
A
So
that
was
already
done
and
all
components
are
healthy
within
the
flux
system.
So
we're
good
to
go.
I'm
going
to
go
ahead
and
go
to
where
I
keep
my
code.
A
Notice
this'll
happen
so
far
without
writing
any
code
or
for
for
for
bootstrap
and
convenience
only
and
to
help
make
this
process
much
easier
on
you.
The
flux,
bootstrap
command
does
write
this
git
repo.
As
you
can
see.
Well
I'll
show
you
now.
A
Yes,
it's
there.
I
just
created
this
two
minutes
ago
now,
so
you
do
not
have
to
use
the
bootstrap
command
to
install
flux.
A
A
So
I'm
going
to
just
show
you
now
that
I
have
I've
cloned
that
repo
that
it's
made
into
my
local
cd
into
into
that
repo,
and
now
I'm
going
to
go
ahead
and
show
you
the
files
that
it
made
you
can
inspect
them
when
you
want
to
the
geotk
components,
shows
you
literally
everything
that
flux
needs
to
run.
A
A
Let's,
let's
go
ahead
now
quickly
and
I'm
gonna
simulate
a
a
helm
release.
A
You
probably
have
one
or
dozens
or
possibly
hundreds
in
your
cluster,
that
you've
made
using
amazing
made
using
the
helm
cli
either
manually
or
through
automation,
and
and
I'm
just
going
to
go
ahead
and
use
the
pod
info
chart
which
installs
this
pod
info
app.
That
was
written
by
stefan
rodin
as
an
example,
because
it's
it
loads
quickly
and
it's
good
for
demos.
A
Something
slightly
more
complex,
I'm
going
to
add
custom
values
too
and
show
you
how
the
how
how
the
flux
cli
tool
allows
you
to
migrate
those
very
easily
from
your
existing
home
installations
into
a
declaration
for
your
home
release.
So
you
can
see
that
I'm
just
going
to
go
ahead
and
use
a
few
of
them.
Replica
count
log
level
and
I
wanted
to
show
you
a
nested
one.
So
I'll
just
do
ui
color.
A
Those
are
here
in
the
normal
helm
way
again.
This
is
doing
nothing
with
flux.
Yet
I
just
have
it
installed
waiting
for
us
and
I
will
go
ahead
and
do
do
a
helm,
cli
installation
using
the
upgrade
dash
dash,
install
or
dash
I
command,
making
a
release
called
my
release
of
the
pod
info,
the
pod
info
chart
and
you
can
see
you
can
use
normal
helm
tools,
helm
s,
helm
list
to
see
that
that's
there
and
it's
not
revision
one.
A
So
I'm
going
to
go
ahead
and
create
a
custom
source,
sorry,
a
custom
resource
locally
for
the
helm,
repository
that
maps
to
to
really
the
same
thing
that
we
did.
Excuse
me
here
with
helm,
repo
ad,
the
name
of
the
name
of
the
repo
and
the
path.
A
This
is
very
similar.
We're
going
to
do.
Instead,
flux
create
source
helm,
which
is
a
a
helm,
repo
definition
that's
in
the
cluster
and
we're
going
to
give
it
the
url
I'm
going
to
tell
it
what
name
space
I'm
going
to
use
the
default
namespace
just
for
now,
and
I'm
going
to
export
it
into
a
file
as
opposed
to
loading
it
directly
imperatively
into
the
cluster,
because
we
want
to
do
this,
declaratively,
I'm
showing
you
how
to
do
it.
A
Oh,
I
see
I
went
to
the
wrong
tab.
Okay,
thanks
for
your
patience
there,
okay,
so
so
let
me
show
you
what
that
looks
like,
and
this
is
it
that
just
shows
you
ultimately
the
same,
and
this
is
really
just
the
information
about
the
home
repository.
Okay,
there
are
several
ways
to.
There
are
several
different
types
of
sources
for
a
helm
chart
with
flux.
A
This
is
just
using
the
most
popular
one
at
home,
repo
there's
also
just
to
get
a
folder
in
git
or
a
git
source
itself,
so
you
can
have
a
a
custom
helm
chart
or
something
like
that
inside
of
your
git
repo,
and
that
will
work.
A
You
can
also
use
a
storage
bucket,
an
s
any
s3
compatible
bucket,
whether
mineo
or
any
other
cloud
provider's
version
of
a
storage
bucket
and
coming
very
soon,
you'll
be
able
to
use
oci
as
a
source.
Now
that
that
is
a
full
feature
in
helm,
that's
pretty
big
news.
We
have
by
pushing
that
through
and
congratulations
to
all
the
rest
of
the
helm
team.
A
On
that
too,
we
we
now
have
unblocked
sdk
users,
specific,
including
flux
for
from
doing
that
too,
and
providing
that
support,
so
there's
a
design
document
in
progress
or
in
process
and
there's
actually
going
to
be
a
demo
of
this
working
with
the
source
controller,
with
oci
working
as
a
source
at
the
next
community
flux
meeting.
So
please
join
that
it'll
be
next
next
thursday
or
if
you
watch
this
recording
afterwards,
you
can
go
back
and
look
at
the
recording
of
that
community
flux.
A
The
demo
at
that
community
flex
meeting
it's
pretty
exciting.
So
next
we're
going
to
create
a
helm,
release,
custom
resource
locally.
A
A
So
you
don't
want
to
have
to
to
to
give
the
information
over
and
over
about
your
home
repo
as
a
source,
especially
if
it's
a
private
repo
and
you
need
off
and
other
things
like
that
for
your
source.
A
So
you
do
that
once
and
then
we
reference
that
when
we
create
the
home
release,
custom
resource,
so
just
to
show
you
the
the
example
with
values
I'm
going
to
go
ahead
and
get
use
the
helmcli,
as
you
normally
would
to
get
those
values
into
a
file
and
show
you
how
easy
it
is
to
migrate
those
into
your
home
release
when
you
create
your
custom
resource,
so
I'm
gonna
go
ahead
and
do
helm,
get
values
and
I'll
show
you
what
that
looks
like
in
the
my
values
file.
I
just
downloaded.
A
That's
what
I
just
said
we
were.
We
were
we
had
created
when
we
deployed
the
chart
and
now
the
flux
cli
has
a
command
that
makes
it
super
easy
to
create
the
sound
resource.
I'm
calling
it
my
release,
because
that's
what
we
did.
That's
the
release
name
and
the
source
is
the
helm
repository
that
I
just
mentioned.
So
it's
a
pointer,
not
all
the
information
about
it,
because
that
object
will
be
there
on
its
own.
The
chart
is
the
pub
info
chart
we're
giving
a
simvar
constraint
for
the
version.
A
It's
just
got
to
be
above
4.0,
we're
telling
it
the
default
namespace
and
we're
importing
the
values
automatically
from
that
file.
This
command
that
could
be
loaded.
Direct
excuse
me
that
could
be
loaded
directly
into
the
cube
api,
but
this
command
exports
it
into
a
file
for
so
we
can
do
this
declaratively,
I'm
going
to
do
that,
and
I'm
going
to
show
you
that
file.
A
Just
so
you
see
what
this
looks
like
and
there
we
have
it.
You
can
see
that
the
values
for
the
chart
itself
are
their
own,
its
own
map
and
that
works
for
any
chart
here.
So
we
no
longer
need
to
use
this
temporary
values
file,
so
I'm
going
to
remove
it.
I
don't
necessarily
have
to,
but
I'll
do
it
to
stay
tidy.
So
I
can
use
git.
A
Add
everything,
because
now
we're
going
to
go
ahead
and
deploy
this
to
our
repo
you
purely
using
by
pushing
to
get
and
that
will
work
because
the
the
flux
components
specifically
the
customized
controller,
is
looking
at
our
excuse
me.
The
source
controller
is
looking
at
our
source
and
when
we
push
it
there
that
will
be
automatically
imported
into
our
cluster
so
and
do
we
get
status?
You
can
see
these
two
new
files,
I'm
gonna,
do
again
commit
for
now.
I'm
just
gonna
do
something
simple
I'll.
A
So,
let's
go
ahead
and
check
out
the
magic.
Now,
if
you,
if
you
had
a
longer
timeout
you
could
you
you
could
demo
this
by
using
the
flux
record
soft
command.
We
don't
need
to
do
that
because
we
set
the
limit
to
10.
We
set
the
the
interval
to
10
seconds,
so
I'm
going
to
go
ahead
and
I'm
going
to
go
ahead
and
show
you
that
that
should
have
already
changed.
A
Flux
should
have
already
taken
over
this
helm
release
that
you
would
earlier
made
with
the
cli
I'll
show
you
this
by
first
doing
a
helm
list
again.
It's
now
revision
status,
2
and
that's
because
flux
have
added
labels
to
those
resources
and
updated
to
the
new
revision
there.
So
I'm
going
to
go
ahead
and
show
you
the
deploy,
object,
managed
by
that
chart
oops
here
I'll,
just
go
ahead
and
show
you
the
ammo
itself,
so
you
can
see
it
in
context.
A
If
you
look
under
the
labels,
flux
adds
late.
Excuse
me,
the
flux
controller
adds
labels
for
this
to
denote
that
it's
controlling
this,
but
you
know,
let's
don't
take
my
word
for
it.
Let's,
let's,
let's
prove
it
here:
I'm
gonna
go
ahead
and
update
the
the
helm,
release,
custom
resource
that
flux
understands
and
push
it
just
through
git,
and
that
should
update
our
home
release
as
well.
So
I'm
gonna,
I'm
going
to
add
my
change.
I'm
just
changing
the
ui
from
red
to
blue.
A
Let
me
let
me
get
a
visual
here.
A
A
Yeah,
you
can
see
that
when
we
first
launched
the
the
helm
chart,
we
we
colored
it
red,
I'm
going
to
go,
do
let
me
go
ahead
and
do
a
git
push.
A
And
as
long
as
once
that
revision
updates.
A
It's
in
between
revisions;
now
there
we
go
once
that
revision
updates.
I
should
be
able
to
port
forward
this
again
and
show
you
that,
just
by
pushing
to
get
it
automatically
changed
that
helm,
release.
A
Okay,
so
we
did
that
we
showed
you
that
it
worked.
We
get
to
the
visual
on
regard,
it's
blue,
okay,
so
that's
that's!
That
is
really
great.
It
should,
and
that
shows
you
how
the
helm
release
object
and
that
the
I,
the
concept
of
home
release
itself,
is
retained
in
the
cluster
using
this
tool
for
get
ops.
A
That
is
not
the
case
with
all
tools.
There
are
different
strategies,
but
we
think
that
there's
a
high
value
in
being
able
to
still
use
the
helm
cli
as
you
need
it,
for
example,
during
instant
management.
So
if
you
wanted
to
use
home
rollback
here
is
an
example
of
seeing
that
happen
real
fast
and
we're
nearing
the
end
of
this
demo.
So
let's
do.
A
Well,
let's
go
ahead
and
do
in
order
to
do
a
helm,
rollback.
I'm
gonna
show
you
pause
and
resume
how
that
works,
with
the
resources
for
whether
it's,
for
instance,
management
or
for
some
other
purpose.
You
still
as
a
human
operator,
have
the
ability
to
control
what's
happening
with
this
automated
process.
So
don't
let
the
fact
that
don't
let
the
idea
of
continuous
delivery
scare
you
you
can
pull
the
emergency
brake
anytime,
you
want
and
you
don't
have
to
do
it
for
all
of
your
processes.
A
You
can
do
it
on
a
per
home
release
basis,
so
I'll
go
ahead
and
suspend
this
helm
release,
there's
a
handy
command
to
do
that.
You
can
also
do
it
with
annotations.
You
don't
need
to
use
the
flux
cli
at
all,
but
this
is
just
very
convenient
and
then
let's
go
ahead
and
roll
back
to
the
last
revision
back
from
blue
to
red
and
to
be
clear,
the
reason
that
we've
suspended
this
is
because
I
have
this
on
a
very
the
interval
on
a
10
second
interval.
A
So,
even
if
I
have
done
a
helm,
rollback,
10
seconds
or
half
the
time,
five
seconds
or
less
later
it
would
flux,
would
automatically
heal
that
and
take
and
and
and
change
my
roll.
My
manual
helm
roll
back
back
to
the
desired
state
that
I
have
specified
in
in
git,
so
we
we
paused
it
in
order
to
show
you
that
this
can
happen
I'll,
pour
it
forward
again.
A
So
you
excuse
me
I'll
put
four
port
forward
again,
so
you
can
see
that
we're
back
to
red
and
then
I'll
go
ahead
and
resume
say
we're
finished
with
our
incident
management
or
whatever
we
wanted
to
do
and
we're
going
to
go
ahead
and
and
resume
reconciliation,
automatic
reconciliation.
A
So
now
we
can
clean
up
and
we
can
do
a
kind
delete
cluster
to
clean
up,
but
don't
go
away
yet
because
there's
a
big
gotcha
here.
While
this
is
a
cleanup,
I'm
gonna
go
ahead
and
use
this
to
show
you
one
last
thing:
you
could
delete
your
helm,
your
your
git
repo.
Now
this
demo
get
repo,
but
wait.
There's
more
now
that
we
deleted
this
cluster,
I'm
going
to
go
ahead
and
show
you
how
flux
flux
handles
your
helm
releases
in
a
disaster
recovery
scenario.
A
A
In
the
meantime,
I'll
describe
to
you
why
this
is
valuable.
It
may
be
obvious
just
from
what
I've
shown
you
so
far,
but
this
is
not
something
that
most
kubernetes
users,
helm,
users
or
kubernetes
users
have
the
ability
to
do
normally
when
you're,
when
your
cluster
is
deleted,
you
have
to
rerun
a
lot
of
things
to
make
that
happen,
so
I'm
going
to
bootstrap
this
again
this
time
it'll
go
much
faster
because
it
doesn't
have
to
create
that
repository.
A
This
command
is
item
potent,
so
you
can
run
it
over
and
over
without
fear
of
messing
something
up.
It
sees
that
there's
a
cluster
in
place.
It
finds
that
deploy
key.
It
generates
the
source
secret.
A
It
puts
the
proper
the
proper
keys
in
place
for
access
and
as
soon
as
the
the
flux
components
are,
are
healthy
and
running.
A
We
it
will
will
automatically
reconcile
your
home
release
that
you
have
specified
and
get
if
you
had
more
than
one.
If
you
had
hundreds
of
them,
it
would
do
the
same
thing,
and
so
now
it's
done.
Let's
do
a
helm
list.
A
And
you
can
see
it
running
right
now,
so
there
we
have
it
thanks
very
much
I'll
go
back
down
to
the
bottom.
That's
basically
a
wrap
just
as
a
quick
review
of
what
we
of
what
we
of
what
we
did
so
that
you
can
walk
away
and
remember
this
without
necessarily
having
to
watch
every
step
of
the
video
again
on
a
local
kind
cluster.
A
We
used
the
flux
cli
to
bootstrap
flux,
components
into
the
cluster,
simultaneously
define
and
create,
if
a
a
git
repo
for
you,
if
it
didn't
already
exist
and
and
go
ahead
and
include
them,
its
own
manifests
for
itself
to
run
in
that
git
repo,
so
that
if
that
cluster
died
just
then
you
could
run
the
fl
you
could
you
could
go
ahead
and
get
flux
back
up
and
running
just
from
git.
A
So
it
also
gives
you
a
lot
of
visibility
into
exactly
what's
on
there
and
what
it's
doing,
there's
really
no
magic
behind
the
scenes
that
you're
that
you
should
be
unaware
of
it's
all,
very
accessible,
that's
good
for
security!
Folks,
we
use
the
flux
cli
to
easily
create
custom
resources
for
the
helm,
repo
and
the
helm.
Release
which
can
multiple
releases
can
reference
that
repo,
along
with
our
existing
helm,
releases,
custom
values
that
we
wrote
when
we
first
used
the
helm
cli
to
make
it.
A
That
was
pretty
cool
for
those
of
you
that
that
have
more
complex
charts
or
lots
of
values,
maybe
values
from
different
environments.
You
can
immediately
see
the
benefit
of
that
convenience
function.
A
We
pushed
the
files
to
get
and
we
we
showed
how
the
flux
labels
are
there,
which
means
it
has
taken
ownership
of
managing
that
existing
home
release
that
you
had
earlier
deployed
with
the
helmcli,
and
we
proved
that
that
actually
is
managed
by
making
changes
to
get
only
and
we
watched
flux
magically
update
your
home
release
from
git.
A
We
showed
you
how
to
pause
and
resume
which
you
might
do
use
during
in
cluster
development
or
incident
management,
and
we
simulated
disaster
recovery
of
your
helm
release
by
deleting
the
entire
cluster.
All
we
had
to
do
was
bootstrap
flux
again
onto
a
new
cluster,
and
we
got
your
application
up
and
running
again.
A
So
I
hope
that
helps
give
you
an
idea
of
the
power
of
flux
for
helm
users,
why
you,
as
a
helm
user,
would
want
to
do
helm
declaratively,
and
you
would
want
flux
to
do
that
and
how,
additionally,
by
using
flux,
you
are
using
you're
getting
all
of
the
benefits
of
github
says.
A
So,
thanks
a
lot
and
we'll
see
you
in
the
q
a.