►
From YouTube: TGI Kubernetes 035: WeaveWorks Flux and GitOps
Description
0:00:00 Hello and Welcome
0:02:20 Plan for the episode
0:03:00 Recent Kubernetes news review
0:03:25 New swag! Heptio and Kubernetes keycaps
0:06:35 Heptio is hiring!
0:07:34 Heptio in NYC
0:08:44 Kubernetes Discourse!
https://discuss.kubernetes.io
0:10:26 CoreOS/Red Hat integration plans
https://www.redhat.com/en/about/press-releases/red-hat-unveils-roadmap-coreos-integration-red-hat-openshift
0:12:14 Flatcar Linux (fork of CoreOS)
https://www.flatcar-linux.org/
0:13:46 Operator Framework
https://coreos.com/blog/introducing-operator-framework
0:15:10 Envoy Operator
https://medium.com/solo-io/introducing-the-envoy-operator-for-kubernetes-d59dc75e6d8c
0:17:45 gVisor
https://cloudplatform.googleblog.com/2018/05/Open-sourcing-gVisor-a-sandboxed-container-runtime.html
https://github.com/google/gvisor
Microsoft Drawbridge: https://www.microsoft.com/en-us/research/project/drawbridge/
0:21:30 CNCF Certified Kubernetes Application Developer (CKAD) exam
https://www.cncf.io/announcement/2018/05/02/cloud-native-computing-foundation-announces-launch-of-certified-kubernetes-application-developer-ckad-exam/
0:22:12 Defining GitOps
https://www.weave.works/blog/gitops-operations-by-pull-request
0:29:41 GitOps compared to Spinnaker
0:30:49 Layering w/ GitOps, App def vs. app def manipulation vs. app def application
0:33:40 kubediff for diffing local config vs. cluster config
https://github.com/weaveworks/kubediff
0:34:07 Sealed secrets from Bitnami
https://github.com/bitnami-labs/sealed-secrets
0:35:49 Helm and GitOps?
https://www.weave.works/blog/helmflux
0:37:30 Weave Cloud and Weave Flux
https://www.weave.works/features/continuous-delivery/
0:38:40 Replica scaling and GitOps
0:39:20 Installing Weave Flux
0:41:13 Looking at install YAML
0:42:48 Setting the git repo
0:44:04 Flux RBAC
0:48:01 Actually deploying Flux
0:49:43 Flux "Big Red Button"?
0:51:15 Connecting to Flux/installing fluxctl
0:59:09 Connecting Flux to our git repo
1:02:05 Looking at flux secrets
1:06:36 Flux terminology: Controllers
1:09:00 List images
1:10:00 Updating image (release) on controller
1:12:45 Flux and templating systems?
1:13:54 Connecting to Hello World application
1:14:53 Automating updates when new images pushed
1:17:14 Rolling back an update
1:20:10 Deautomate
1:22:23 Semver for image tags?
1:23:50 Locking a controller
1:25:23 Editing files in git directly
1:34:14 More features! Changing git author, image tag filtering
1:35:59 Wrapping up!
1:38:50 Kris taking on more TGIKs
Come hang out with Joe Beda as he does a bit of hands on exploration of Kubernetes and related topics. Some of this will be Joe talking about the things he knows well. Some of this will be Joe exploring something new with the audience. Ask questions, comment and help decide where things go.
In this post-KubeCon episode we'll cover some impressions from the conference and announcements from other CoreOS/Redhat, Microsoft and beyond. Then we'll dive into the idea of "GitOps" and how those ideas are used in WeaveWorks Flux.
A
Hello
and
welcome
to
another
edition
of
t
GI
kubernetes.
It
is
Friday
again,
and
this
is
episode.
35
I'm
really
happy
to
be
back
from
cube
con
and
ready
to
talk
to
everybody
and
yeah.
So
let's
get
started.
Can
you
all
hear
me
fine?
Yes,
everything
av
issues,
nothing
going
on
there
who's
worried
because
you
know
it
all
works
and
then
I
find
I
talk
for
five
minutes
and
find
out
that
nobody
can
hear
us
so
yeah.
So,
let's
say
hi
to
everybody.
A
So
we
have
Mateus
how's
it
going
lumati
good
to
see
you
Suresh
Ilyas
here,
okay,
so
I'll
talk
about
well,
thank
you
for
being
with
us,
Marko,
Gabriel
Sean,
so
Antoine
garrison
people
who
say
it's
time:
Arnaud
Keith
from
Scotland
awesome,
Jacob,
joy
I
did
Fabio
from
Portugal
Florian
Saeed
from
London
I
moth
from
Bangalore.
That's
awesome!
Thank
you!
So
much
for
joining
us.
Everyone,
Rory
VIN,
Jay
Lukas,
see
engine
and
is
an
Istanbul
Brian
from
Denmark.
A
I
was
just
out
there
for
kube
Khan
had
a
lot
of
fun,
no
is
in
Vegas
and
then
Brian's
over
in
on
the
East
Coast
there
good
to
see
you
Brian
Bob
Florian's
in
Sweden,
Caleb
in
Arkansas
and
Salvador
in
Spain,
and
the
steve-o's
in
Croatia.
Alright.
So
that's
awesome,
I'm,
just
I'm,
always
blown
away
that
so
many
folks
are
are
joining
from
all
over
the
world.
It
really
a
super
super
cool,
so
Ilya
is
on
there.
A
So
Ilya
is
one
of
the
folks
at
we've
works
and
he's
joining
us
instead
of
drinking
a
beer
at
the
pub
tonight,
because
he's
based
in
I,
believe,
London
and
and
so
he's
joining
us,
because
the
topic
that
we're
talking
about
today
is
going
to
be
get-ups
and
we're
gonna
be
looking
at
weave
flux,
which
is
a
project
that
works
with
the
ideas
of
get
up.
So
what
I'm
hoping
to
do
through
this
is
to
define
what
get-ups
is
and
it's
from
the
philosophy
behind
it
and
they
will
look
at
sort
of.
A
You
know
what
tools
can
help
you
do
that.
What
are
you
know
which
tools
can
work
together
here?
Which
tools
are
a
little
bit
more
of
a
forced
fit
and
then
I'm
going
to
play
with
with
weed
flux
and
and
actually
sort
of
put
it
through
its
paces
and
make
it
work.
So
that's
a
plan
we'll
see
how
far
we
can
get
going
on
there,
yeah
so
Philip
from
Bonn,
Germany
and
Gopal
from
the
Netherlands
awesome
awesome
all
right.
A
So
these
are.
These
are
custom
key
caps
that
I
had
made
they're
a
little
bit
blurry
here.
Maybe
that's
a
little
bit
better
and
you
can
see
like
you
know,
so
these
go
on
sort
of
mechanical
keyboards
and,
and
so
I
spent
like
way
too
much
time
like
researching
what
these,
how
these
things
work,
but
there's
a
whole
like
if
you
folks
who
are
in
the
know,
know
that
there's
this
whole
subculture
on
mechanical
keyboards,
you
know
old-school,
switches
and
stuff
and
creating
custom
caps
form
and
cap
sets
and
stuff
like
that.
A
A
So
it's
not
an
imprint,
and
so
they
actually
wear
really
well,
and
you
can
see
if
you
look
sort
of
on
the
on
the
underside,
you
can
see
where
some
of
the
some
of
the
black
plastic
is
and
so
yeah
so
I
did
I
did
a
cooper,
Nettie's
logo
and
a
heftier
logo,
and
then
these
are
the
the
way
that
they
attach
to
the
switch
this.
This
is
the
Cherry
MX
10
stem
and
it's
probably
the
most
common
out
there.
A
There
are
some
other
ones
out
there
that
that
folks
use
and
then
there's
this
ol.
The
next
thing
is
the
profile,
so
this
is
sort
of
the
shape
of
the
key
and
there's
all
sorts
of
different
profiles.
These
are
something
that's
similar
to
what
you'll
find
in,
like
Oh
am
sort
of
traditional
keyboards.
A
little
bit
shorter
and
I
made
these
for
like
the
top
two
row.
So
this
is
works
well
as
an
escape
key
or
a
number
key,
and
so
on.
A
But
but
yeah
so
they
turned
out
really
well
and
they
screwed
up
and
like
I.
You
know,
I
I
thought
that
all
of
the
the
hefty
o
keys
were
misprinted
cuz.
They
actually
did
it
upside
down
or
logo
was
actually
directional,
even
though,
if
you're
not
used
to
seeing
it,
you
don't
see
that,
but
it
looks
like
it
was
only
half
of
those,
so
I
still
have
some
of
those.
A
So
now
the
question
is:
how
do
you
get
one
of
these
because
they're
super
cool
I'm
gonna
be
at
glue
con
in
outside
of
Denver
next
week?
Doing
a
doing
a
talk
and
we're
gonna
have
a
booth
there.
So
I'm
definitely
gonna
bring
a
couple
of
bags
of
these
along
with
so
that
you
can
all
come
and
grab
one
if
you're,
if
you're
there,
otherwise
we're
going
to
have
these
at
at
various
meetups
and
such
and
and
one
of
the
other
things
we're
starting
to
do
is,
as
folks
help
out
on
our
open
source
projects.
A
We
definitely
find
want
to
find
ways
to
to
say
thank
you
to
them,
and
so
that's
one
of
the
other
things
that
we're
looking
at.
In
terms
of
being
able
to
to
get
there,
and
so
chris
says
that
we're
working
on
a
public
hemp
deal
conference
calendar
so
that
if
folks
want
to
come
meet
with
us
and
talk
with
us,
we
can
actually
have
a
place
to
go
where
they
can
find
that
stuff
out
so
yeah.
So
look.
The
other
way
is
that
you
can
come
join
hefty.
A
Oh,
we
are
hiring,
and
so
the,
if
you
do,
that,
will
even
give
you
a
t-shirt.
You
know,
along
with
a
salary,
so
that's
the
way
that
works.
So
I'm
gonna
catch
up
on
some
of
the
comments
here.
So
so
Sean
says
he
has
an
f5
key
key
cap
from
when
he
I
made
for
my
keyboard.
Since
she
worked
at
f5,
that's
awesome,
yeah,
so
I
I,
don't
like
the
cherry,
MX
temps.
Do,
though,
those
work
on
the
like
the
super
old
IBM,
keyboards
I
never
actually
pulled
a
key
cap
off
I.
A
Don't
know
if
that,
how
far
back
that
that
standard
goes
so
yeah,
yeah
and
so
New,
York
I,
think
you
know,
we
definitely
have
some
folks
in
New
York
we'll
send
some
off
there.
Maybe
they
can
take
him
to
some
to
some
meetups
and
stuff,
so
that'll
be
actually
be
good
too
so
yeah
all
right.
So
that's
there.
We
go
all
right.
So
that's
my
fun
thing.
I'm
super
excited
about
these.
They
came
out
really
really
nice
and
they
just
they
feel
really
substantial,
all
right,
Oh
who's
in
New
York.
A
So
so
we
got
a
couple
of
folks
in
New.
York,
probably
you
know,
Chuck
is
out
there
and
he's
working
on.
Oh
gosh
he's
doing
some
stuff
with
QA
diem.
At
this
point
and
there's
some
other
folks
in
New,
York
too
I
don't
want
to
I.
Don't
want
to
add
him.
I
think
Chuck
would
be
ok
with
me
saying
his
name
on
the
air
here,
but
others
yeah.
So
you
know-
and
this
is
actually
one
of
the
interesting
things
and
I
just
want
to
I-
want
to
touch
on
this.
A
Where
you
don't
have
to
be
out
in
front,
you
don't
have
to
be
a
big
personality,
not
everybody's
comfortable
with
that
so
yeah.
So
that's
why
I'm
like
there
are
people
in
New
York,
but
I
don't
want
to
I,
don't
want
to
call
attention
to
that
all
right.
So
let
me
switch
to
my
screen.
Wind
go
ahead
and
get
started
and
try
and
get
through
this
stuff
pretty
fast.
So
the
first
thing
I
want
to
talk
about
is
discussed.
October
Nettie's,
dot
IO.
So
this
is
something
that
Oh
Gabriel
yeah.
A
So
you
know,
Chris
may
take
you
up
on
that.
This
is
something
that
George
Castro,
who
is
a
community
manager
for
for
for
kubernetes
and
fto.
Employee
has
been
working
to
set
up
with
the
contributor
experience
sig
and
we're
looking
for
new
ways
to
communicate
new
ways
to
build
community
inside
of
inside
of
kubernetes.
So
this
is
an
experiment
with
using
discourse
as
a
forum
as
something
that's
kind
of
halfway
in
between
slack,
which
is
super
ephemeral
to
email,
which
is
kind
of
a
you
know,
old-school
we're
trying
to
think.
A
Can
we
actually
have
something
that
that
is,
you
know
more
purpose-built
for
larger
communities,
so
so
I'm
really
excited
about
this
and
it's
open
for
business
now
so
I
really
want.
You
know
everybody
who's
on
here,
I'd
love
you
to
sign
up
and
and
get
involved.
So
it's
discussed,
kubernetes
io.
Let
me
see
if
I
think,
I'm
allowed
to
put
URLs
in
this
thing.
Let's
see
so
if
you
go
there,
I'm
just
gonna
work
we'll
see:
oh
wait,
no!
Okay,
so
it
doesn't
show
up
on
the
screen,
but
I
don't
know.
A
If
it
shows
up
for
the
rest
of
you
yeah,
so
so
I'm
really
excited
about
seeing
that
happen,
so
I
would
love
to
have
you
you'll,
sign
up
and
find
ways
to
to
start
working
on
this
I
think
right
now
this
is
is
more
general
stuff,
but
I
think
we'll
look
and
we'll
look
to
see
how
we
can
grow
the
categories
there
and
and
really
start
focusing
the
discussions
so
so
good
job
to
George
and
the
Contra
backs
folks
to
actually
get
going
there.
I'm
really
excited
about
that.
So
that's
super
cool.
A
Please
sign
up
alright.
So
the
next
thing
I
want
to
talk
about,
and
this
was
something
that
was
announced
at
the
Red
Hat
conference
recently.
Is
they
they
started
getting
some
more
detail,
some
more
meat
on
the
bones
on
how
the
core,
OS
and
Red
Hat
stuff
was
going
to
start
coming
together.
I
think
this
brings
some
clarity,
but
also
there's
a
lot
of
questions
too.
A
Don't
know
what
this
means
for
RedHat
atomic
but
I
believe
this
will
displace
atomic
they're
gonna,
rename
it
to
red
hat
core
OS,
so
the
actual
operating
system
was
called
core
OS
and
then,
as
the
company
core
OS,
actually
got
more
serious
about
doing
things
beyond
the
OS.
They
renamed
it
to
container
linux.
But
now
it's
getting
reading
back
to
core
OS.
So
it's
red
hat
core
OS
is
now
the
actual
OS.
A
But
then
also
as
part
of
that,
you
know
the
the
you
know:
I'm,
not
I'm,
not
a
total
Linux
distribution
nerd,
but
but
core
OS
was
was
based
on
on
gen
2.
It
was.
There
was
a
huge
focus
on
being
as
up-to-date
as
possible.
It
looks
like
they're
gonna
rebase
it
on
top
of
fedora
and
so
there's
a
lot
of
folks
scratching
their
heads
wondering
exactly
what
that's
gonna
mean
and
how
that's
going
to
work
so
so
it
will
live
forward
in
some
way.
A
A
A
They
do
a
lot
of
development
for
folks
really
great
group
of
folks
Lily,
who
was
there
is
now
at
weave,
so
so
they're,
the
ones
sort
of
like
also
providing
a
path
forward
for
folks
who
are
using
using
core
OS.
Oh
the
Maddy
says
a
virtual
cubelets.
Yes,
I
could
talk
forever
about
virtual
cubelet
or
lap
forever.
I
could
say
a
lot
about
I'm,
not
sure
we
have
time,
but
that's
definitely
a
lot
of
exciting
stuff
going
on
about
that
all
right.
A
So
that's
that
that's
the
the
flatcar
Linux
and
then
there's
the
and
then
there's
you
know
smashing
together
of
core
West
stuff
and
Red
Hat
stuff
and
then
Quay
will
live
on
they're,
going
to
open
source
some
stuff
or
that
so
there's
a
lot
in
this
press
release.
There's
been
a
few
sort
of
clarifications
on
Twitter
and
stuff
too
so
yeah.
A
Let's
see
videos
on
YouTube
of
the
talk,
if
you
search
for
a
Red,
Hat
summit,
core
OS,
okay,
so
yeah,
so
folks
can
go
ahead
and
find
that
for
more
info,
I
am
NOT
the
expert
okay,
the
other
interesting
thing
that
the
Korres
folks
did
is,
or
the
Red
Hat
folks
did.
I
I'm
still
confused
on.
Why
there's
like
they're
still
Corollas
calm
and
are
they
gonna
merge
these
things
together?
A
How
does
this
work
so
I,
don't
even
know,
I,
don't
even
know
what's
going
on,
but
there's
the
operator
framework
stuff,
which
is,
is
something
that
I
think
it's
been
going
on
for
a
while,
which
is
you
know,
creating
an
SDK
to
make
it
easy
to
create
operators,
and
this
isn't
something
that
I've
played
with
yet.
But
it's
both
you
know
creating
out
making
it
easy
to
create
operators
making
easy
to
deploy
and
manage
those
things
and
then
apparently
there's
a
there's.
A
metering
component
that's
coming
along.
Also,
this
is
super
interesting,
I.
A
There's
like
there
is
a
sort
of
you
know,
academic
discussion
on
what
exactly
an
operator
is
to
some
degree.
You
know
the
simple
stuff
that
you
can
do
with
this
framework
is
something
as
simple
as
just
like,
having
a
bunch
of
parameters
that
then
go
ahead
and
expand
using
a
templating
system
and
get
deployed.
So
so
there
is
a
blurry
line
between
this
stuff
and
say
something
like
helm
to
some
degree
and
and
there's
even
as
part
of
this
framework,
there's
a
way
to
essentially
turn
a
helm
chart
into
an
operator
and
I.
A
Think
if
we
look
at
there's
this
new
there's,
you
know
the
there's.
The
the
solo
do,
folks,
who
they
do
this
there's
a
glue,
GL
oo,
API
gateway
thing.
They
have
this
Envoy
operator,
and
it's
really
in
that
in
that
mode,
where
it
just
like,
has
a
domain-specific
way
to
deploy
this
stuff
right.
So
it's
it's
nothing
more
than
templating
on
top
of
a
deployment
I,
don't
know
if
that's
an
operator
or
not
so
I'm
really
kind
of
kind
of
unsure
about
that.
A
Is
this
idea
if
I
search
for
catalogue?
Oh
no,
it's
not
in
there,
so
they
didn't
they
didn't.
Are
they
if
you
start
looking
at
the
at
the
at
the
actual
code?
And
if
you
look
at
the
lifecycle
manager,
there's
there's
actually
this
idea
of
a
catalog
that
is
also
driven
by
CR,
DS
and
stuff.
So
it
definitely
feels
like,
like
there's
a
there's,
there's
a
convergence
across
a
whole
bunch
of
things
that
have
been
going
on
in
kubernetes
and
to
me
that
just
means
that
you
know
interesting
stuff
is
gonna,
come
out
so
yeah.
A
A
You
know
lots
of
folks
are
doing
that,
so
the
the
virtual
cubelet
yeah.
We
should
do
something
on
that
or
dig
into
that
in
some
ways.
Maybe
maybe
Chris
can
take
down
at
some
point
the
so
it's
operator
framework
/,
awesome
yeah.
So
if
you
go
to
the
github
organization
for
the
for
the
the
operator
framework,
they
actually
have
a
list
of
operators
there
Ilias
like
I.
Hopefully
this
can
finally
converge
the
three
operator
kits
on
github,
so
we
have
and
then
there's
my
medic
control,
I
love,
meta
controller,
I.
A
Think
if
you're
going
to
do
this
thing,
where
you
like,
create
a
sort
of
a
really
simple
type
of
thing.
I
think
medic
controller
is
a
great
solution
for
that.
But
it's
definitely
in
some
ways
in
the
same
vein,
yeah
so
yeah.
So
that's
that's
some
of
the
stuff
going
on
there.
Okay,
let's
keep
moving.
So
that's
the
Envoy
operator,
all
right,
so
G
Weiser
was
one
of
the
big
things
that
would
Google
and
cube
con,
which
is
really
exciting.
A
Now
this
has
been
floating
around
for
a
long
time
inside
of
Google,
and
it's
essentially,
oh
man,
I
mean
it's
like
it's
it's
moving
the
pieces
around.
One
way
to
think
about
this
is
that
it's
a
more
secure,
container,
runtime
sort
of
sandbox
technology.
Another
way
to
think
about
this
is
that
it's
sort
of
you
know
a
hypervisor.
That's
like,
ultimately,
para.
You
know
a
pair
of
virtualized
right
so,
instead
of
just
parallel
virtual
izing,
the
driver
you're,
actually
para
virtualizing
the
entire
kernel.
So
that's
really
really
interesting.
A
One
of
the
things
that
I
think
is
worth
digging
into
here
is
that
if
you
start
looking
at
the
the
code
underneath
this
stuff,
let's
see
if
you
look
at
the
readme
for
gee
visor
and
you
start
reading
through
that,
what
you'll
find
is
that
it
runs
in
two
modes
in
terms
of
the
technology
that
it
works.
Where
did
it
go?
Maybe
they
changed
it?
A
Okay,
platforms
here
yeah,
so
it
runs
in
two
modes.
So
one
of
them
is
a
Pete
Ray
sandbox,
which
means
that
it
does
this
really
expensive
sort
of
tracing
of
the
of
the
workload
as
it
runs
and
any
time
a
syscall
is
called.
It
goes
through
grabs
that
implements
the
syscall
and
user
mode
and
then
send
it
back.
So
it's
kind
of
like
fuse
for
everything
and
then
and
then
there's
a
KVM
thing,
which
is
probably
they
mark
this
as
experimental.
A
But
this
is
the
thing
that
I
think
really
a
long
term
is
going
to
be
the
place
where
G
Weiser
sing
so
that
the
performance
hit
for
the
KVM
stuff
is
going
to
be
a
heck
of
a
lot
lower,
and
so
this
is
very
similar
in
some
ways
to
it's
a
hypervisor.
But
but
you
know
every
every
syscall
turns
into
a
hyper
call.
So
there's
essentially
no
kernel
running
inside
of
the
VM.
A
So
in
terms
of
comparing
this
with
with
the
Linux
clear
containers,
I
don't
know
if
they
do
that,
they
I
think
there
is
some
comparison
to
cata
containers.
The
big
difference
there
is
that,
with
with
something
like
Quetta
containers
or
even
like
anything,
built
on
Linux
kit,
you're
still
running
a
cur
inside
the
guest
there's
a
Linux
kernel,
it
has
its
own
file
system,
its
own
memory
management,
its
own,
its
own
caches,
its
own.
A
You
know
IP
stack
and
all
that
tcp/ip
stack,
the
the
what
this
does
is
it
takes
everything:
that's
in
the
kernel,
re-implement
sit
and
go
in
user
mode
and
then
host
it
outside
of
the
outside
of
the
the
VM
right.
So
it's
really
I
think
the
most
similar
thing
out
there.
If
you
want
to
do
some
researches
there's
this
Microsoft
research
project
called
drawbridge
that
was
done
probably
about
ten
years
ago.
A
Now,
okay,
like
not
quite
so
long,
where
essentially
there's
a
sort
of
mini
kernel,
they
call
it
picot
processes
and
there's
an
API
boundary,
and
then
then
that
goes
across
a
security
boundary
and
they
only
have
45
calls
across
that.
So
this
was
a
research
project
out
of
Microsoft
I,
don't
think
it
ever
actually
saw
its
way
into
products,
but
there
you
go
yeah
and
so
kind
of
containers.
It
has
a
real
kernel
running
inside
the
running
inside
the
inside
the
guest.
A
The
biggest
thing
here
is
compatibility.
It's
the
big
question.
I
think
you
know
these.
The
G
Weiser
folks
have
been
working
for
a
long
time
to
get
a
lot
of
stuff
running,
but
there
may
be
subtle
compatibility
issues
there,
so
yeah.
So
that's
all
right,
so
I'm
totally
way
off
topic
here,
but
it's
super
interesting
stuff.
Ok,
let's
keep
going
and
then-
and
then
the
last
thing
I
want
to
do.
A
Is
that
there's
a
new
certification
that
the
CNC
F
did
around
application
developers,
and
so
this
is
the
CK
ad
exam
where,
as
one
app
and
one
certification
is
about
how
to
administer
and
run
clusters,
this
one
is
about
how
do
you
actually
build
stuff
on
top
of
the
clusters?
These
things
are
still
relatively
new,
but
but
it's
good
to
actually
see
sort
of
more
resources
out
there
for
this
stuff,
so
yeah,
alright,
so
I
am
like
way
into
the
episode
here,
but
hopefully
that
was
interesting
for
y'all.
A
Alright,
alright,
let's
jump
in
to
get
ops
so
get
ops
is
a
catchy
term
that
the
we
folks
came
up
with.
This
definitely
feels
like
it's
an
Alexis
thing:
I,
don't
alia
you
can
tell
me
who
came
up
with
get-ups
was
that
was
that
Alexis?
It
totally
sounds
like
Alexis
and
I.
Think
it's
a
great
way
to
describe
the
this
sort
of
this
philosophy.
A
Around
sort
of
where
do
you
actually
store
your
idealized
date
as
you're
running
applications
in
a
cluster
and
so
yeah,
so
yeah
Alexis
I,
know
Alexis
cornered
me
a
little
while
ago,
he's
like
I
really
want
to
make.
This
phrase
happen
now,
like
I,
actually
think
it's
a
really
it's
a
really
good
idea,
but
it
comes
down
to
this
so
like
in
traditional
systems
like
like
in
the
battle
days
of
like
sis
Ops
type
of
things.
You
know
the
I'd
like
like
what
was
running
on
a
machine
was
what
was
running
on
a
machine.
A
So
it's
like
people
would
bring
up
machines.
They
would
configure
them
by
hand,
they
would
run
it
and
then,
and
then
maybe
they'd
have
a
spreadsheet
someplace
that
had
an
idea
of
like
what
should
be
running
on
which
machine
and
then
and
so
then,
that
spawned
a
whole
industry
of
this.
This
thing
called
inventory
management,
which
is
a
total
enterprise-e
thing,
which
is
essentially
a
way
of
saying
what
the
heck's
running
on
all
my
machines
right,
and
so
it
was.
A
A
Kubernetes
takes
care
of
actually
making
sure
it's
no
longer
running,
so
so
the
source
of
truth
for
what
should
be
running
and
being
able
to
audit
what
is
running
all
that
stuff
sits
with
kubernetes
and
that's
a
huge
step
forward,
because,
instead
of
having
what's
running
on
the
machines
running
on
the
machine
or
what
puppet
says
and
what
the
machine
says
can
be
different,
we
actually
have
a
system.
That's
built
to
continuously
reconcile
the
desired
idea
of
what
should
be
running
and
what's
actually
running
yeah.
A
A
The
API
for
kubernetes
is
the
the
definitive
source
of
what
what
is
and
should
be
running,
and
if
you
have
something
running
your
machine
that
you
know
that
is
magnified
kubernetes,
but
the
kubernetes
api
doesn't
report
it.
Well,
that's
a
bug,
that's
something
that
we
definitely
want
to
want
to
make
sure
it
doesn't
happen.
Now.
A
The
next
problem
here
is
well:
how
do
you
manage
the
stuff
that's
running
inside
if
your
kubernetes
cluster
and
I
think
this
is
where
things
get
really
interesting,
because
not
everybody
agrees
on
this
and
is
the
is
the
the
stuff
running
in
your
cluster?
Is
that
your
source
of
truth
like
if
it's
running
in
the
cluster,
then
that's
what
it
should
be?
And
in
some
this
feels
a
little
bit
like
the
bad
old
sis
up
states
right.
A
So
if
somebody
goes
into
kubernetes
and
like
edits,
you
know,
does
acute
control,
edits
and
starts
like
tweaking
stuff?
Well,
that's
the
new
world
right,
that's
that
happen,
and
there
are
ways
to
get
audit
logs
on
who
did
what
when
and
where.
But
it's
not
like.
There
aren't
tools
built
for
that,
and
so,
if
you
operate
in
this
sort
of
imperative
and
declarative
mode
with
kubernetes
as
a
source
of
truth,
then
tools
like
cute
control
run
really
work
well
there.
So
you
do
a
cute
control
run.
A
It
creates
some
stuff
in
the
cluster
it's
running
boom,
you're
done
right
and
that
mop
model
works
well
with
like
tools
like
hep
teal
arc,
because
arc
is
like
hey.
Let
me
look
at
what's
running
in
the
cluster
and
being
able
to
back
that
up
and
actually
restore
it
now.
The
other
way
of
thinking
about
this
is
actually
going
full
declarative.
A
Where
you're
you
manage
your
manifests
outside
and
then
you
apply
those
things
right
and
now
that's
in
some
ways
similar
to
to
something
like,
like
you
know,
puppet
or
shadow
Jeffery,
ansible
right
now,
there's
this
question
of
like
well,
let's
say:
I
have
all
my
ammo,
all
my
manifest
checked
into
a
git
repo
and
I
have
stuff
running.
I
still
have
to
go
through
and
actually
make
sure
I
take
the
stuff
in
the
git.
A
Repo
and
I
apply
it
to
my
cluster,
and
so
that
is
is
what
a
lot
of
folks
are
doing,
but
it's
possible
for
those
things
to
get
out
of
sync.
You
could
have
somebody
go
and
edit
the
thing
behind
the
back.
You
know
directly,
you
could
have
somebody
make
a
change
and
then
forget
to
push
it,
and
so
you
end
up
with
this
disconnect
that
can
happen
there.
So
let
me
get
catch-up
with
the
comments
here.
A
Yeah
so
actual
stay
yeah,
so
Oh
John
said
that,
like
copy
and
paste
from
the
word
document
into
multiple
punny
sessions-
oh
that's
horrifying!
Alright
yeah!
This
is
like
like
horrifying
a
storytime,
so
some
talk
about
Jenkins
yeah,
so
Jenkins
is
moving
in.
You
know
more
in
the
direction
of
working
well
with
these
systems,
which
I
think
is
really
interesting.
A
So
yeah,
and
so
it's
C
so
Jason
saying,
did
we've
put
a
repo
that
shows
there
applied
if
pipelines.
Well,
that's
the
tool
we
flux.
Does
it
I,
don't
know
if
they've
actually
showed
the
stuff
that
they
actually,
what
they're
actually
running
in
production,
I
think
they'd
be
interesting
and
then,
and
then
Illya
is
like.
The
fun
part
is
when
you
extend
kubernetes
api
with
CR
DS
that
do
much
more
yeah.
A
So
as
we
look
at
with
operators
in
this
stuff,
all
of
a
sudden
we're
you
know,
the
set
of
state
is
actually
expanding
dramatically
in
terms
of
what
we're
actually
applying
and
what
we
want
to
reconcile.
So
the
idea
with
git
ops
is
that
you
say
my
source
of
truth
of
what
should
be
running
is
not
the
cluster.
A
It's
actually
a
get
repo,
and
not
only
is
it
the
get
repo
I
don't
want
to
have
it
be
a
human
operation
to
take
that
get
repo
and
apply
it
to
the
cluster
I
want
it
to
be
an
automatic
operation
as
soon
as
I
submit
stuff
to
get
things
happen
and
the
thing
gets
a
ploy
deployed
and
I
think.
It's
also
interesting
to
look
at
this,
maybe
in
comparison
to
something
like
like
spinnaker.
So
spinnaker
is
a
deployment
methodology.
A
So
one
of
the
other
things
that
you
get
out
of
using
source
control,
the
manager
configs,
is
that
you
get
history.
You
get
code
reviews
you
get
all
sorts
of
tooling
that
you
can
build
on
top
of
that
stuff,
so
that
definitely
helps
quite
a
bit
all
right.
So
that's
my
take
on
sort
of
what
get
ops
is
now
you
can
go
ahead
and
I'll
include
the
link
in
the
show
notes.
A
You
can
read
the
the
post
on
this
stuff
that
I
think
Alexis
definitely
wrote
this
one
that
talks
about
how
they
work
on
this
I
think
I
think
our
our
yeah.
So
here's
the
thing
so
so
Simchat
says
the
spinnaker.
You
I
loves
that
I
agree
to
I
think
a
good
UI
on
top
of
this,
but
I
think
good
layering
on
this
stuff.
A
So
the
way
that
you
could
do
get
ops
with
a
good
UI
is
that,
instead
of
going
through
and
actually
editing
it
directly,
you
can
interact
with
something
that
then
goes
ahead
and
does
the
git
manipulation
for
you
on
your
behalf
with
your
name
attached
to
it.
So
you
could
build
a
slack
bot
to
do
that.
You
could
build
a
UI,
but
at
the
end
of
the
day,
the
source
of
truth
that
everybody's
operating
from
and
with
is
a
get
repo.
A
Alright,
so
drone
with
the
the
the
cube
CI
cube,
cube
control,
plug-in
to
deploy
everything,
yeah
I
think
you
know,
there's
there's,
there's
definitely
other
other
tools
out
there
that
do
that.
So
I
don't
want
to
pretend
that
something
like
fluxes
is
the
only
way
to
go
now.
What's
interesting,
is
that
how
you
manage
that
yeah
Milland?
How
you
create
that
manual
is
a
separable
process
from
how
you
deploy
them
the
mo
right.
So
so,
there's
a
lot
of
things
that
something
like
flux
or
get
ops
can
be
compatible
with.
A
You
can
do
get
ups
with
case
on
it
right
where
case
on.
It
is
a
way
that
you
do
the
templating.
You
do
the
expansion,
but
the
end
of
the
day.
You
end
up
with
a
set
of
llamó
that
you
apply
now
you
can
either
apply
it
to
cube
control
or
you
can
apply
it
through
through
other
tools
that
do
it,
but
you,
but
the
source
of
truth
is
actually
sitting
in
get
in
some
sort
of
machine,
readable
format.
There's
you
can
use
helm
in
a
mode
where
you
render
a
client
side.
A
You
can,
let's
see,
there's
there's
a
ton
of
different
sort
of
templating
solutions
out
there
in
terms
of
how
to
actually
manage
and
create
that
yeah
moe.
So
so
that's
a
separable
problem
and
so
I
think
there's
this
there's
this
there's
this
layering
that
I'd
love
to
see
happen
between
application
definition,
application,
manipulation
and
application
application
definition,
rendering
or
application
so
I'm
using
application
in
two
different
senses
here.
So
so,
there's
like
your
app
def,
your
app
def.
You
know
modifications.
A
Do
you
edit
files
directly
or
their
other
ways,
and
then
how
do
you
take
your
app
def
and
actually
apply
it,
and
so
those
are
all
separable
things
and
the
the
tool
that
we're
gonna
be
looking
at
with
we
flux.
Is
that
last
thing?
How
do
you
actually
go
ahead
and
apply
it?
It
does
a
little
bit
of
the
the
app
def
manipulation
around
image
tags
and
we'll
see
that
also.
But
it's
really
that
last
thing
that
that
is
really
the
most
interesting.
A
Is
this
yeah,
so
this
is
a
dipping
tool
that
showed
the
difference
between
running
stayed
in
the
version
controlled,
stuff,
yeah
I
believe
there's,
there's
some
other
cool
tools
that
are
out
there
too,
that
do
similar
stuff
like
there
some
of
this
stuff
built
into
caisson
it
also
it's
there.
We
go
save
that
here,
we'll
put
it
there
all
right.
A
So,
let's
get
up
now,
one
of
the
things
that
actually
gets
gets
hairy
here
as
things
that,
like
hey
great
I,
want
to
check
everything
in
to
get
oh,
what
do
I
do
with
like
secrets
and
passwords
and
stuff
like
that?
There's
this
really
cool
solution
that
the
the
bitNami
folks
put
together
called
sealed
secrets,
and
so
this
is
a
CR
D
for
putting
encrypted
secrets
that
you
may
or
may
not
be
comfortable
putting
into
into
source
control
where
they're
encrypted
and
then
the
decryption
happens
after
you've
actually
applied
them
to
the
cluster.
A
A
Unfortunately,
helm
doesn't
do
that
yeah,
so
I
think
there's
this
whole
other
yeah,
so
being
able
to
create
a
bundle
that
contains
sort
of
like
a
container
for
your
continued
stuff
right.
That
includes
both
this
config
plus
all
the
other
stuff
that
go
along
with
it.
I.
Don't
think,
we've
actually
seen
that
that
happen.
Yet
there's
been
some
efforts
there,
but
but
we're
still
pretty
early
days
on
that.
A
This
is
Valerie,
says,
there's
been
some
talk
and
see,
gaps
around
bundling
concepts
and
what
doesn't
happen
compass,
but
it's
hard
to
answer
yeah.
So
there's
this
idea
of
the
app
CR
D,
which
is
like
metadata
about
an
app,
but
it
really
doesn't
quite
get
to
the
fact
that
I
want
to
bundle
all
this
stuff
up.
Some
of
this
comes
down
to
the
fact
that
that
including
your
docker
images
with
that
bundle
can
be
complicated
and
of
itself
from
a
security
signing.
A
A
They
have
their
own
weave
cloud
thing
and
part
of
weave
cloud
is
integration
with
integration
with
the
the
the
get
up
stuff,
so
they
can
provide
a
UI
on
top
of
Gaddafi's
I
haven't
used
it,
but
I
think
this
actually
starts
looking
at
like
this
would
be
something
that
sits
in
that
app
deft
manipulation,
side
of
the
house
right
and
also
probably
gives
you
some
other
status
on
stuff.
Oh
look,
and
it
has
a
picture
of
Luke
Luke's
no
longer
a
week.
A
He
did
this
this
dot
mesh
thing,
which
is
this
really
cool
sort
of
get
applied
to
data
thing.
So
I
mentioned
that
at
one
point,
I'd
love
to
to
do
that
in
a
TGI
K
episode
and
play
with
it.
So
all
right.
So
that's
that
alright!
So
that's
my
setup,
any
questions
before
we
start
diving
into
the
tool.
Hopefully
this
is
a
good
definition
of
sort
of
what
get-ups
is
and
why
it's
interesting
and
sort
of
the
benefits
that
folks
will
get
out
of
it.
A
It
doesn't
feel
quite
as
immediate
and
like
Yolo,
let's
get
stuff
done,
but
I
think
in
a
production
setting.
It
really
helps
so
yeah.
One
of
the
other
interesting
things
is
that
if
you're
doing
manually
scaling
of
replicas
right
I
think
you
know
what
it
means
is
then
you're
not
going
to
do
a
cube,
ctrl
scale
anymore.
What
you
do
is
you
go
through
and
you
actually
change
your
manifest.
A
And
we're
not
going
to
do
that
because
I
think
you
know,
that's
like
I
want
to
stick
to
the
to
the
purely
open-source
parts.
So
we're
going
to
do
a
manual
install
of
we
flux
here,
and
so
the
first
thing
I
need
to
do
probably
is
actually
cloned
this
directory,
and
so,
like
all
the
doc
in
the
flux.
Repo
is
under
sight
here
and
I.
Don't
know
if
this
get
hosted
someplace
is
there
like
a
I,
didn't
actually
see
like
a
pointer
from
the
readme
to
actually
a
site
where
this
guy
gets
rendered
out.
A
So
we're
gonna
just
look
at
the
markdown
and
github
directly
most
of
the
instructions
here
at
least
the
installation
and
setup
stuff
assume
that
you're
using
we've
cloud.
If
you
want
the
standalone
stuff,
you
have
to
go
into
the
standalone
directory
here
and
we're
gonna
go
ahead
and
start
with
installing
there,
but
first
I
need
to
clone
this
thing,
because
I
haven't
done
that
yet
and
we
will
do
git,
clone
flux.
A
And
there
we
go
okay,
and
so
can
you
all
see
this
I
think
we're
good?
Okay,
alright,
so
we
do
I.
Think
I
do
IV
s
code
running
there.
We
go
okay,
so
we
can
look
in
flux
and
there's
a
whole
bunch
of
stuff
here,
but
there's
the
deploy
stuff
and
that's
the
directory
that
that
matters
here.
For
this
and
let's
look,
we
have.
A
Clone
the
flux,
repo
and
edit
the
example
configuration
flux
deployment.
This
creates
all
the
resource
in
the
deployed
directory,
ok,
flux,
deployment,
Gamal,
ok,
so,
ok
and
then
do
the
rest
of
it.
So
let's
go
ahead.
We're
gonna
go
through
because
we're
gonna
install
all
this
stuff
and
if
you've
been
watching
TJ
before
you
will
know
that
I
really
like
to
examine
the
amyl
that
we're
about
to
install
in
detail
so
that
we
can
really
really
understand
what's
happening
here.
Okay,
so
deployment,
the
strategy
is
recreate.
A
I
believe
what
that
means
is
that
it
doesn't
do
a
rolling
update
it
actually
does
it
down
and
then
up
type
of
thing.
So
that
means
that
when
you
update
the
version
of
flux,
it'll
take
flux
down,
you
know
temporarily,
that's
probably
completely
ok
for
something
like
this
and
it
probably
helps
to
prevent
you
know
multiple
things
of
flux,
sort
of
fighting
with
each
other.
A
Let's
see,
there's
a
secret
that
gets
to
that
gets
created
into
flow
called
flux,
get
deploy,
we'll
have
to
look
to
see.
What's
in
that
secret
and
then
there's
a
temp
FS
used
for
generating
the
SSH
keys
in
kubernetes
mounted
secrets
are
read-only,
so
we
need
a
separate
volume
move
that
we
can
write
to
for
generating
the
SSH
keys.
Okay
and
then-
and
you
don't
want
to
write
that
stuff
in
someplace,
where
it
might
leak
out.
A
You
want
to
be
careful
with
that
stuff,
and
then
we
have
a
container
called
flux
and
there's
the
there's
the
tag
1.3.
It
does
some
stuff
on
30-30
and
then
it
maps
in
that
get
key
and
they
get
key
gen
stuff
and
then
we're
gonna
be
passing
in
the
key
John
key
gen
path
and
the
oh
and
then
there's
a
URL
that
we
can
use
called
flux
example.
So,
let's
go
through
and
we've.
A
So
here
is
an
example
of
some
stuff
that's
running
and
we
have
a
whole
warp,
hello,
world
service
and
deployment
and
then
oh
and
then
here's
some
sidecar
stuff
that
happens,
so
we
can
go
ahead
and
play
around
with
that.
This
runs
a
sidecar
and
a
master
and
all
that
so
ok.
So
what
we're
gonna
do
here
is
I'm
going
to
fork
this,
because
there
we
go
I'm
going
to
fork
it
into
I,
create
my
own
special
thing,
because
I
don't
want
private,
hefty
Oh
repos
to
accidentally
be
exposed
to
the
world.
A
So
we're
going
to
use
this
as
our
github
repo
that
we're
working
against,
and
so
this
is
so
it's
it's
your
your
SSH
based
clone
thing
here,
so
I
wonder
if
you
can
use
HTTPS
here
all
right
and
then
include
these
next
to
connect
to
an
upstream
service,
we've
cloud,
the
token
in
particular
as
the
service.
So
this
is
how
you
can
connect
a
weave
cloud,
so
I'd
be
interested
to
look
to
see
what
that.
What
that
interaction
looks
like
ok,
cool
all
right,
so
we
got
that
going
on.
A
A
So
that
means
that
flux
has
root
on
your
cluster,
something
for
you
to
keep
in
mind
and
then
those
things
get
bound
together,
because
flux
is
actually
going
through
and
and
and
mucking
with,
your
your
you
know,
pretty
much
doing
anything
to
do
a
deployment.
I
think
that
this
makes
sense.
It
might
be
interesting.
You
know,
to
see
if
there's
a
way
to
deploy
flux
for
a
single
namespace,
because
I
think
I
would
be
I
would
be
comfortable,
saying,
hey.
A
You
know,
I'm
using
flux
to
actually
manage
this
namespace,
but
I
really
don't
want
flux
to
actually
have
route
with
cube
system
right
and
doing
that
sort
of
everything,
except
that
namespace
type
of
thing
is
not
possible
with
our
back.
So
there's
no
sort
of
like
hey
this,
but
not
that
it
really
is
just
additive.
A
Do
this
thing
in
a
in
a
in
a
you
know:
do
this
thing
in
a
namespace
by
namespace
point
of
view,
what
this
also
means
and
I
think
you
know
helm
has
some
of
the
issues.
Is
that
that
the
flux
you
know
the
way
that
you
talk
to
flux,
because
there's
this
port
30
30
here?
If
that
actually
is
a
control
port?
How
is
that
authenticated
right?
Or
is
that
only
information?
Because
if,
if
you
can
actually
sort
of
manipulate
things
that
way,
then
maybe
that's
a
way
of
getting
route
on
the
cluster?
A
So
so
you
know
you
got
to
understand.
You
know
when
you
look
at
your
threat
model
that
that
you're
you're
expanding
your
threat
model
by
running
something
like
this
with
route.
Alright,
so
then
there's
a
node
port,
so
we
have
a
node
port
where
port
80
is
being
mapped
to
30
30
I.
Don't
want
to
do
port
80
because
that's
gonna
squad
on
a
port,
that's
across
a
bunch
of
other
stuff,
so
or
no
so
yeah
nope,
so
yeah!
A
So
no
we're
not
going
to
do
yeah
well,
do
will
do,
will
do
30,
30
there
and
the
target
port
is
30,
30,
okay
and
then
there's
secrets.
This
is
the
get
deploy
secret
it
going
to
start
out
with
nothing
in
it
and
then
one
of
the
things
and
we'll
get
to
it
is
that
I
think,
let's
start
with
flux,
just
doing
that,
hey
you
change
kid,
and
then
it
actually
applies
it.
A
Another
thing
that
flux
can
do
is
that
it
can
actually
pull
look
at
a
docker
image,
repo
and
and
if
there's
a
newer
tag,
it
can
take
that
tag
and
then
I
believe
edit
get
to
rewrite
the
manifest
so
that
it
actually
so
this
is
so.
This
is
the
place
where
flux
actually
plays
some
of
that
app
dev,
editor
role,
right,
app,
Det,
def,
manipulation,
role
based
on
watching
a
repo,
and
it
gets
bundled
into
the
same
thing
but
I.
A
Think,
logically,
you
could
think
about
that
sort
of
hey
watch
for
updates
to
the
the
image
tags
has
been
a
separable
thing
from
okay.
Now
I
want
to
be
able
to
apply
this
stuff,
so
this
is
mem.
So
it,
but
that
thing
as
it
is
doing
polling
and
so
as
it
does,
that
it
wants
to
actually
store
its
date
and
that's
where
the
memcache
here
is,
so
that's
there's
a
service
and
independence
around
that
and
then
and
then,
let's
see
and
then,
when
we
look
at
the
deployment
replicas
one.
A
So
there's
gonna
be
one
of
these
that
that's
running
now.
The
other
interesting
thing
here
is
that
this
stuff
is
all
nothing.
Nothing
here
says
which
namespaces
this
is
going
to
be
deployed
to
so
so
by
default.
This
will
get
deployed
to
the
default
namespace,
because
that's
what
I
have
set
up.
So
let's
go
ahead
and
do
that
so
flux
deploy
or
we
go
back
here.
Okay,
so
we'll
do
keep
control
applied
a
shaft.
So
we
do
this
if
all
goes
well,
it'll
actually
sort
of
do
in
the
right
order.
Yep!
Oh.
A
It
didn't
do
in
the
right
order
because
it
created
the
deployment
and
in
the
secret.
Well,
you
know
why
it
didn't
do
in
the
right
order.
This
is
interesting.
Is
that
most
of
the
times
when
folks
reference
secrets,
they
only
know
it
is,
it
is
actually
mounted
as
a
volume.
Oh
well,
it'll
get
updated,
so
that
should
work.
Okay,.
A
A
So
Illya
says
non
SSA.
Toth
options
vary
so
much.
We
don't
support
it
yet
as
there
isn't
a
common
denominator
yeah.
So
the
reason
we
do
image
updates
is
that
if
you
were
to
do
just
get
reconciliation,
you'd
keep
making
PRS
to
update
the
image
I'm.
Okay,
with
that,
to
be
honest,
I
think
this
is
probably
like
sort
of
you
know.
Arguments
about.
A
Is
it
true
get
ops
when
you
have
state
that's
actually
existing
outside
of
it
right,
and
so,
if,
in
my
mind
like
you
should
be
able
to
use,
you
know
you
should
be
able
to
go
to
the
git
repo
and
apply
it
directly.
Let's
say
that
that
flux
breaks,
you
should
be
able
to
go
to
that,
go
to
that
git
directory
and
if
you
have
the
right
permissions
apply
it
out-of-band
from
what
gift.
A
I
want
all
the
state
of
what
should
be
running
or
the
last
thing
applied
to
actually
be
sitting
in
in
the
git
repo.
So
in
my
mind,
actually
going
and
doing
the
the
get
updates
would
be
the
right
way
to
do
this
stuff.
So
it
also
sure
that
the
image
gets
deployed
is
actually
in
the
registry.
I
think
that's
a
good
check
also,
but
I
would
vote.
A
I
would
view
that
as
a
deployment
pre
check
right
of
like
hey
before
I
deploy
I
want
to
actually
go
through
and
make
sure
that
it's
actually
in
the
in
the
registry.
Okay,
so
he
always
says
you
can
freeze
objects
with
annotations.
Okay,
so
there
is
a
way
to
actually
do
that
by
the
objects.
I
would
would
I
would
have
a
config
thing
that
says
you
know,
because
anytime,
you
have
these
automatic
systems
they're,
incredibly
powerful,
but
that
power
can
be
used
to
destroy.
Also
so
I
would
love
to
see
in
a
system
like
this.
A
You
know
the
big
red
button
right
if
something's
going
wrong,
I
want
to
make
sure
that
everybody
calms
down.
Well,
we
figure
out
what's
going
wrong,
so
yeah,
okay,
cool,
so
but
let's
go
ahead
and
play
with
it.
I
think
you
know
those
are.
These
are
all
opinions,
I,
think
the
the
general
sort
of
gist
of
how
this
stuff
works
is
consistent
across
these
things,
all
right,
so
we
got
stuff
up
and
running.
There's
a
detailed
description.
A
We
went
through
a
bunch
of
that
whether
or
not
you
have
our
back
I'm
glad
to
see
that
our
back
is
the
default
here,
at
least
being
our
back
aware.
Okay,
to
make
the
pot
accessible
to
the
command
line,
client
flux
control,
you
will
need
to
expose
the
API
outside
the
cluster.
A
simple
way
to
do
this:
use
port
forward.
I
love
me
some
port
forward.
This
example
here
uses
uses
some
cube
control
magic
to
try
and
get
the
the
name
of
the
pod.
A
A
Like
do
I
have
the
permissions
to
say
you
know
what
turn
flux
off
in
my
namespace
alright,
because
this
is
my
team's
main
iam
suus,
without
impacting
other
people
that
are
perhaps
running
on
the
same
cluster.
So
I
really
like
to
think
about
those
things
in
terms
of
like
how
do
things
look
as
we
move
towards
multi
team
clusters,
all
right,
so
they
okay,
so
this
is
is
so.
This
is
the
Voodoo
that
you
need
to
do
to
be
able
to
actually
pull
out.
A
The
name
of
the
pod
that
got
created
from
the
deployment
but
folks
who've
been
watching
will
know
that
was
cute
control
version.
One
point
ten:
you
can
actually
do
this.
It's
built
into
port
forward
to
be
able
to
do
this
stuff,
which
I
am
incredibly
excited
about,
so
so
we'll
go
ahead
and
we'll
get
to
that
I.
Don't
have
flux,
flux,
control,
yet
flux
cuddle.
A
A
There's
a
certain
amount
of
steps
here,
just
Ilia,
so
feedback
that
are
left
as
exercises
to
the
reader,
because
most
users
won't
know
and
I.
Don't
know
if
and
I
see
this
as
a
stumbling
block
a
lot
of
times
when
I
look
at
stuff.
Is
that
you're,
like
hey
just
download
the
latest
one
from
github?
Well
I
just
did
that,
but
Oh
move
flux,
control
I'm
in
the
wrong
directory.
A
You
know
seeing
how
to
do
it
with
curl
and
then
I
got
it
or
maybe
it
ends
up
in
your
downloads.
If
you
click
the
link,
but
now
I
have
to
do
as
mod
+
ex
flux
control
on
this
thing,
which
is
like
like
the
number
of
users
that
know
that
you
have
to
schmod
this
after
you
download,
it
is
going
to
be
even
smaller
and
I'm
gonna
wreck
rename
this
stuff
and
then
move.
A
And
then
you
have
to
move
it
to
someplace
in
your
path.
Otherwise,
you're
gonna
have
a
bad
time
right.
So,
like
all
those
little
things
actually
get
complicated
for
folks,
so
I
think
having
some
better
instructions,
there
will
help
or
do
in
the
doing
the
hound
chart
stuff
for
KS
the
case.
Sonic
client
we
use
go
releaser,
which
is
a
really
cool
project
that
helps
build
up,
helm,
charts
so
yeah.
So
so
now
so
now
I
have
flux
control,
but
it
doesn't
know
how
to
actually
talk
to
the
the
flux
service.
A
A
One
of
the
things
that
does
not
do
just
buyer
beware
is:
it
does
not
reconnect
if
that
pod
disappears.
So
if
you're
talking
to
a
deployment-
and
you
actually
do
an
update,
you're
going
to
have
to
stop
and
restart
the
port
forward
command
just
like
before,
but
at
least
now-
you
can
do
that
in
an
automated
way
without
having
to
actually
do
some
of
the
some
of
the
said,
Voodoo,
that's
going
on
here,
alright,
so
we
got
that
up
and
running,
oh
and
then
I
have
to
go
through
and
and
do
this
stuff.
A
A
Let's
see
so
I
can't
make
my
screen
bigger,
because
you
guys
can't
see
that
so
I
can
make
the
font
just
a
little
bit
a
little
bit
smaller,
alright,
so
and
I'm.
Sorry,
we
folks
at
Burnie
calcio
in
this
cluster,
all
right,
so
so
that's
cool,
so
so
flux
control,
if
I
just
run
that
there's
automate
d,
automate
identity
list
controllers
all
sorts
of
stuff.
Here
this
identity
is
the
way
that
flux
talks
to
the
git
repos
right.
A
How
do
I
go
through
and
and
like
if
I
go
through
and
actually
do
a?
You
know
a
mutating
thing
here,
like
this
automate
and
stuff
like
that
or
manage
policies
and
stuff,
like
that
lack
of
control?
How
do
I
and
maybe
look
this
lock,
ends
up
being
a
ends
up
being
the
equivalent
of
the
big
red
button?
But
you
know
how
does
this
actually
get
authenticated?
How
does
it
work
in
a
multi
team
process?
A
I
think
you
know
without
a
good
authentication
story
between
the
client
and
that
Damon
I
worry
that
this
has
a
lot
of
the
okay.
So
it
goes
over
well,
no
because
we're
doing
port
forward,
so
we're
actually
talking
to
this
thing
directly.
So
it's
probably
not
going
to
maybe
goes
over
a
WebSocket
or
maybe
use
this
G
RPC
there.
But
is
it
authenticated?
And
that's
that's
the
question
in
my
mind,
because
you
know
this
isn't
quite
as
powerful,
I,
don't
think
as
as
helm,
but
yeah
okay,
so
lock
turns
into
an
annotation.
Okay.
A
Well,
we'll
go
ahead!
We'll
take
a
look
at
this
stuff
and
we'll
go
through
the
examples,
but
I
do
I.
Do
worry
a
little
bit
about
X
exactly
how
this
stuff
works,
and
it
could
be
that
these
things
actually
use
your
credentials
from
cube
control
to
be
able
to
talk
to
this
stuff.
So
it
may
not
actually
be
talking
over
that
I'd
love
to
see
the
API
between
flux,
control
and
the
flux,
daemon
and
understand
sort
of
what
the
risk
profile
is.
A
If
that
thing
is
not,
it
authenticated
all
right
boom
boom
and
we're
not
doing
the
helm
stuff.
So
all
right
so
now
connecting
to
the
flux
we
did
this,
so
you
can
use
node
pour
like
they
have
all
sorts
of
different
things,
but
we
got
it
working
now.
Okay,
connect
flux
to
a
repository,
so
we
did
this
by
the
get
URL
own.
We
didn't
do
get
branch.
A
A
A
We
got
the
identity
there,
okay,
so
so
we
can
take
so
now
what
we
do
and
again
it'd
be
great
to
see
this
stuff
be
SuperDuper,
explicit
and
then
the
public
key
will
need
to
be
given
the
service
hose
in
the
gate
repository.
So
okay,
so
create
a
deploy
key
in
the
repo.
So
we're
gonna
go
to
our
repo
here
and
we'll
do
settings
and
we'll
do
deploy
keys,
we'll
add
a
deploy,
key
and
oke.
A
A
The
flux
log
should
show
that
it
has
now
connected
to
the
repository
and
synchronize
the
cluster
when
using
kubernetes.
This
key
is
stored
as
a
Cooper
Nate
secret.
You
can
restart
flux
and
it
will
continue
to
use
the
same
key.
Okay,
so
we're
gonna
we're
gonna
we're
gonna
go
ahead
and
do
this
and
then
we're
gonna
look
a
little
bit
under
the
covers,
so,
okay,
so
now,
I
added
that
so
to
read
only
think
here.
Oh
it
was
last
used
within
the
last
week,
so
it
already
started
using
the
thing
okay.
A
So
yes,
we
do
need.
So
it
doesn't
wait.
So
it
does
actually
okay.
So
what
you're
saying
is
it
does
right
back
in
to
get
it
just
doesn't
go
through
the
pr
process
it
just
like
slams
in
the
new
thing
right,
I
think
it's
that
what
you're
saying
anyway,
oh
yeah,
yeah,
okay,
so
okay!
So
let's
go
through
and
I'm
gonna
now
I'm
gonna
now
delete
this
because
okay
I
guess
I
can't
you
can't
edit
it
after
the
fact
we'll
do
that
we'll
do
a
lot
of
row
and
we'll
do
flux
key
here.
A
A
A
Please
do
not
go
through
and
start
vandalizing.
This
get
repo'd
now.
This
is
gonna,
be
more
than
just
typing
a
simple
password
in
right.
Here
we
have
to
take
a
lot
of
effort
to
like
capture
a
screenshot
and
do
this
and
I'm
gonna
delete
this
repo
after
it.
So
those
watching
at
home
don't
make
me
have
to
recreate
this
stuff.
Alright,
so
don't
don't
don't
mess
things
up
for
us
here,
alright,
alright!
So
if
I
do
keep
control
described
secret.
A
We
had
a
PR
mode
in
the
past
and
may
come
back
yeah
I'm
cool
with
this,
not
having
PRS
and
stuff,
but
it
is
interesting.
Maybe
the
PRS
could
actually
be
part
of
a
manual
flow
yeah.
Nobody
start
come
on
guys,
we'll
see
what
happens
okay,
so
this
is
actually
a
big,
obviously
base64-encoded
things
we'll
do
to.
A
A
A
A
A
What
do
we
got
here
so
we
have
flux,
we
have
pods,
we
have
when
you
do
get
all
it
doesn't
actually
tell
you
the
type.
So
that's
got
to
be
the
replica
sets
and
then
there's
like
it's
derived.
Can
you
actually
get
that
okay,
I
didn't
know,
I
thought
you
had
I,
don't
know,
that's
a
good
question:
let's
do
it,
quick
cool,
get
public
key
from
private
key
SSH.
A
A
There
we
go,
you
can
do
ssh-keygen
of
that
thing
and
that
okay,
so
it
is
embedded
in
there,
I
didn't
think
it
was
look
at
that.
Okay
learn
something
every
day,
all
right,
so,
okay,
so
by
storing
the
the
private
key
there
that
I
flashed
on
the
screen,
everybody
be
good.
I
don't
want
you
typing,
like
you
know
all
like,
like
2k
of
that,
but
by
by
storing
that
you
can
actually
get
the
public
key,
so
I
assume
what
I
do
when
I
do
when
we
do
flux,
control,
identity,.
A
A
A
What
do
I
do
now?
Okay,
I
think
what
I
do
now
is
I'm
done
with
the
standalone
instructions,
so
I
go
and
if
I
were
installing
it
with
reflux,
it's
like
setup
flux,
control
and
run
the
daemon.
So
we
do
that
all
right!
So
now
all
right!
So
now
here
we
go
yes,
yes
using
we're
using
okay,
okay!
Well,
this
is
confusing
because
it
says
setup,
flux,
control
and
run
the
daemon,
but
then
it
goes
to
to
using
and
that
doesn't
talk
about
it.
So
the
instructions
are
a
little
bit
off.
A
Yeah,
okay,
so
so
there's
a
so
there's
a
little
bit
of
nomenclature
here
that
may
be
unfamiliar
to
folks.
So
flux
apparently
calls
any
of
the
things
that
sort
of
manage
deployments
for
you
like,
like
deployments
daemon
sets
stateful
sets
cron
jobs,
they
call
those
controllers,
it's
really
sort
of
controller
definitions
or
not
controller
instances.
Controller
manifests
but
like
controllers
for
short,
which
is
different
from
like
an
actual
piece
of
code.
That's
implementing
a
controller,
so
the
name
controller
here
is
a
little
bit
confusing
for
me.
A
What
we
can
go
through
is
we
can
do
we
can
list
controllers,
and
here
we
can
see
that
hello
world.
It's
able
to
do
this.
It
pulled
this
from
it
said
actually
running
cube
control
get
pods,
oh
hello,
worlds,
already
running
okay,
so
it
looks
like
by
default.
It'll
like
read
stuff
from
github
and
actually
apply
it,
so
the
active
actually
adding
that
key
meant
that
flux
could
actually
go
out.
Read
that
manifest
from
github
and
then
actually-
and
you
know,
actuate
it
make
it
happen,
so
I
can
go
through
and
do
a
cube
control.
A
Right,
oh,
wait:
Kail,
okay,
so
this
is.
This
is
looking
at
too
much
stuff.
I
can
do
command.
So
what
are
the
commands?
I,
don't
know
what
the
commands
help
run
version
display
logs
Kail
run,
and
then
we
can
do
de
block.
So
oh
that
doesn't
actually
show
me
the
the
latest
off,
but
like
okay,
so
we're
gonna
go
through
we're.
Gonna
leave
that
running
here.
A
Actually,
no
I'm
gonna
run
it
down
here
so
that
we
can
see.
Oh
sorry,
this
is
not
connected
to
my
cluster
setup
configs.
There
we
go
alright.
There
we
go
so
we're
gonna
leave
this
running.
So
that
means
at
any
time
the
the
flux
stuff
actually
does
something
we'll
actually
see
the
log
output
in
real
time
here.
Alright,
Wow,
okay,
we'll
see
that
okay,
cool.
A
Yeah
cool
alright.
So
now
we
have
okay.
So
now
we
have
this
running,
so
that's
awesome.
So
now
we
can.
Insa
can
also
do
lists
images
here
and
we
can
see
that
each
of
these
things
there's
there's
different
images
and
right
now
the
manifest
is
pointing
to
to
master
a
0,
0,
0,
0,
1
and
then
there's
dates
associated
with
these
I
didn't
know
like
I
guess,
like
each
of
the
tags,
there's
metadata
about
sort
of
when
that
stuff
was
pushed.
Oh
look.
A
We
can
see
fluxes
like
hey
I'm,
checking
to
see
what's
going
on,
there's
like
a
sync
loop
going
on
okay,
so
we
can
see
the
logging
going
on
there
for
those
that
don't
know.
Kale
is
this
cool
tool
that
actually
does
tale
of
a
bunch
of
a
bunch
of
pods
it
once
and
actually
helps
you
to
show
them
all
certain
contexts
together.
So
it's
sort
of
a
better
kubernetes
logs,
okay
and
then
releasing
it
okay,
so
inspecting
the
version
of
a
container.
A
So
we
can
go
ahead
and
we
can
do
that
and
then
we
can
now
go
ahead
and
update
a
controller
with
the
latest
with
the
release
sub
command.
This
will
check
whether
each
controller
needs
to
be
updated
and,
if
so,
write
the
new
configuration
to
the
repository
okay.
So
this
is
actually
going
through
checking
the
thing
and
then
doing
an
update
to
the
latest
and
greatest
version.
A
So
we
can
do
flux,
control
release
and
we
can
just
say:
hey,
you
know
what
for
this
control
or
update
all
images,
and
so
my
name's
not
Phil
we're
gonna
do
two
gik
and
then
there's.
You
can
actually
have
a
message
here
and
all
this
stuff,
so
I'm
gonna
go
ahead
and
do
that
and
then
we're
what
we're
gonna
see
here.
Is
that
there's
a
release
or
it's
doing
its
thing?
A
Well,
we
got
a
lot
of
stuff
going
on
here,
but
now
it's
saying
oh
I've
updated
to
the
latest
version
across
all
these
things,
and
then
it
committed
back
to
the
git
repo
that's
going
on
here,
and
so
we
can
see
that
there's
some
some
fun
stuff
going
on
here
and
then
the
the
and
then
what
we're
gonna
see
and
then
it
pushes
it.
So
now,
if
I
do
cube
control
get
pods.
A
What
we
can
see
is
that
the
hello
world
ones
have
been
updated
and
they
were
updated
as
of
22
seconds
ago
and
then,
if
I
go
and
I
look
at
the
repo
that
I
cloned
yeah.
So
the
other
thing
that
you
you
guys
might
want
to
do
in
your
instructions
here.
Ilia
is
instruct
people
to
fork
that
repo
so
that
they
can
get
the
full
rewrite
experience
to
it
and
actually
point
them
to
that
example.
A
Repo
because
I
think
I've
seen
when
I've
been
playing
with
tools
if
they
have
some
example,
like
an
example,
repo
which
I
think
is
a
great
place
to
start,
and
they
actually
have
a
tutorial
that
uses
that
it
makes
it
much
easier
for
people
to
play
with
this
without
having
to
actually
think
about.
How
do
I
apply
this
to
my
stuff,
all
right,
so
then,
if
I
go
through
and
if
I
look
at
the
commits
here.
A
Yes,
here
we
go
so
here
we
have
a
new
version,
that's
and
it
was
done
by
we
flux,
which
is
the
user
there,
and
it
just
pushed
this
thing
in
using
the
using
the
the
key
there
so
and
I
think
can
I
get
like
more
details
about
this,
commit
like
more
metadata
about
it.
But
okay,
we
can
look
at
that
later,
but
and
what
you
can
see
is
that
it
went
through
and
edited
the
manifest
to
actually
write
in
the
new
version
of
the
new
version
of
the
of
the
ammo,
which
is
definitely
very
cool.
A
So
one
of
the
things
that
I'd
love
to
do
here
and
I
think
you
know,
and
we
haven't
done
an
episode
on
case
on
and
I
think
I'm
wearing
definitely
have
Brian
do
something
very
soon
on
that
is
that,
if
you're
using
a
templating
mechanism,
you
may
find
that
that
your
source
of
truth
is
not
necessarily
the
ammo.
Your
source
of
truth
may
actually
be
the
templates
that
generate
the
ammo
and
so
having
having
a
plug-in
model
with
flux,
so
that
you
can
actually
work
with
it
to
figure
out.
A
A
Okay,
so
this
is
really
cool,
though,
because
it
actually
went
through
and
automatically
said,
hey,
let's
go
find
the
latest
image
and
let's
apply
that
into
the
manifest.
But
yet
I
can
still
look.
I
can
still
go
to
this
to
this
repo
and
look
and
see
here's
the
latest
and
greatest
of
what's
going
on
here.
So
that's
super
cool,
all
right,
very
cool
I.
Don't
even
let's
see
what
the
hello
world
application
does.
A
I
didn't
even
know
what
it
does,
so
cute
control
gets
serviced
and
I
can
do
and
the
hello
world
application
there's
a
port
80
there.
So
cube
control,
port
forward
service,
hello,
world
and
remember.
This
is
just
picking
one
pot
out
of
there.
It's
not
really
connecting
to
the
service
80
80
to
80.
Okay.
So,
let's
see
what
they're
up
port
forward
hello
word
word:
there
we
go.
Okay,
now
I
can
do
localhost,
8080
Hawaii,
all
right!
There
you
go.
That's
the
whole
world
just
says
help,
oh
all
right,
cool!
A
Alright,
let's
see
so
the
next
step
here
would
be
turning
on
automation.
Automation
can
easily
control
within
we've
cloud
by
selecting
the
automate
by
nowhere.
You
can
do
with
flux
control.
So
now
what
I
can
go
through
is
I
can
automate
now
what
does
automate
mean
I
believe
I'm
gonna,
guess
that
automate
means
automatically
update
when
you
push
a
new
image
versus
having
to
manually.
Do
it,
but
it's
not
clear
exactly
what
automation
here
means.
Okay,
so
we
can
do
flux,
control,
automates
will
automate
the
hello
world
thing,
and
this
again
so
this
is
interesting.
A
So
it
says
we
can
see
that
list.
Controller
sub
commands
reports
that
the
hello
world
application
is
automated.
Ok,
so
here
we
go,
flux
will
now
automatically
deploy
a
new
version
of
a
controller
whenever
one
is
available
and
commit
to
the
new
configuration
to
the
configurations.
The
version
control
system.
Okay,
now
do
this
I
guess
that
only
applies
to
things
so,
okay,
so
flex
will
handle
all
yeah
mo.
That's
there
any
amoled
fines,
but
but
the
the
but
a
controller
is
a
special
type
of
Yemma.
A
Manifest
influx
speak
that
actually
has
container
images
in
it
that
it
needs
to
update.
So
there's
nothing
going
on
here
with
the
service
stuff,
either:
okay,
alright!
So
what
so
now
I
can
go
through?
And
okay:
okay,
oh
I!
Guess
you
know!
If
you
wanted
to
do
a
demo,
where
you
were
pushing
your
own
images
and
actually
shows
how
it
catches
that
then
you
would
have
to
yeah,
then
you
then
you
would
have
to
have
a
different
yeah,
have
a
different
repo,
okay!
So
we're
so!
A
Yes
I,
don't
think
I'm
gonna
we're
not
gonna
we're
not
going
to
set
up
the
special
repo
there,
but
okay
and
then
you
can
turn
off
automation
and
then
rolling
back
a
container,
so
rolling
a
vacuum
container
can
be
combined.
Why
so
like?
If
you
want
to
do
a
roll
back
and
you
do
the
D
automate
in
the
release,
deploy
the
version
that
you
want
to
roll
back
to.
A
Yeah,
okay.
This
is
interesting,
though,
because
I
think
to
some
degree,
there's
there's
a
subtle
interaction
here,
because
I
would
almost
expect
that
are
that
a
roll
back
would
be
something
like
a
revert
and
get
right.
So
if
you
go
directly
to
get
and
you
roll
that
back,
you
would
do
that.
But
if
you're
using
this
automation,
there's
a
good
chance
that
the
automation
will
actually
go
through
and
and
undo
your
revert.
If
you
actually
do
it
and
get
directly,
so
you
don't
necessarily
want
to
use
the
get
tools
here.
A
You
want
to
use
release
to
actually
do
a
roll
forward
to
the
previous
version.
Yet,
but
if
you
do
the
revert
and
you
still
had
automate
on
so
let's
say
that
you
turn
on
automate.
You
then
go
through
and
you
then
go
through
and
do
the
it
doesn't
upgrade.
And
then
you
want
to
do
a
rollback.
Well,
you
still
have
automate
on,
and
so
you
don't
actually
see
a
version
of
the
manifest
that
has
automate
off
plus
the
old
version
right
and
in
my
mind
this
is
a
little
bit
of
a
downside
to
using
annotations.
A
So
it's
it's
I,
there's
a
certain
there's
a
certain
elegance
to
actually
using
annotations
here,
but
it
also
seems
like
it's
a
little
bit
overloaded
because
it's
not
actually
part
of
the
deployment,
its
metadata
about
how
flux
interacts
with
the
deployment
so
anyway.
So
let's
go
ahead
and
do
that
we'll
give
this
a
try,
so
we
can
go
through
and
we
can
go
and
if
we
do,
let's
see
we
can
look
at
the
images.
We
can
also
do
flux,
lists
controllers.
A
Flux
control,
okay,
here,
oh
here
we
see
automated,
shows
up
there
and
it
looks
like
it's
automated
if
you're
automating
a
deployment
and
it's
automating
all
of
the
containers
and
the
deployment,
so
you
can't
say:
hey
I
want
to
automate
this
container,
but
I
don't
want
to
automate
this
other
container.
So
it
looks
like
it's
an
all
or
nothing
there,
so
here
it
so
I
liked.
I,
like
this
view
here,
this
is
actually
really
cool,
because
it
shows
all
the
images
in
sorted
order
and
then
it
points
to
the
one
I
do.
A
Imagine,
though,
that
at
some
point
this
could
actually
get
to
be
a
really
really
long
list.
So
I
wonder
if
there's
something
like
pass
like
ten
of
these,
you
just
do
it
like
a
dot
dot
or
something
because
that
could
totally
get
out
of
control,
okay
and
then,
and
then
we
can
do
tomates.
Oh
what's
going
to
happen
here,
is
that
this
is
going
to
actually
do
an
update
to
the
the
git
repo
and
then
do
a
redeploy
of
that
thing
with
the
new
annotation.
So
there
we
go.
A
The
other
interesting
thing
here
is
that
we're
using
an
annotation
to
actually
do
something
like
record
the
policy,
but
we
also
have
another
source
of
truth,
which
is
actually
the
git
repo
itself,
so
it
might
be
possible
to
have
sort
of
a
flux
camel
or
something
like
that.
That's
sitting
in
the
repo
that
never
actually
gets
deployed
to
the
cluster,
because
who
hairs
that's
actually
that
source
of
truth
is
in
there.
A
But
what
that
would
mean,
then,
is
that
when
you
do
like
the
flux
you
know
list
controllers
and
stuff,
it
would
have
to
merge
those
things
together.
So
we'd
have
to
look
at
to
two
pieces
of
data
there.
So
that's
interesting!
Okay,
so
there
we
go
so
that
thing
is
actually
now
running
and
then
you
can
go
through
and
you
we
can
go
through
and
we
can
say:
let's
roll
back
to.
You
know,
update
image
to
to
that.
One
and
it'll
update
one
image:
the
master
image,
but
not
the
other
image.
A
Commit
pushed,
and
then
it's
actually
coming
applied.
Okay,
so
I
love
this
commit
pushed
and
then
applied.
So
you
actually
see
that
stuff
happening
live
there
and
because
this
is
a
controller
type
of
loop,
it
flux
like
crashed
after
he
did
the
commit
before
it
applied
the
next
time
it
came
up,
it
would
actually
go
through
and
not
saying
that
flux
is
crashing.
It
would
actually
go
through
and
reapply
this
stuff.
A
A
Okay,
let's
go
through,
and
we
can
do
that
and
then
okay
yeah
and
then,
if
we
do
the
list
images
again,
we'll
actually
see
that
it
move
the
marker
back
here
versus
the
latest
one.
Now,
it's
interesting
also
that
these
the
order
of
these
things
is
based
on
the
time
that
they
were
pushed
not
based
on
sorting
the
the
tags
themselves
and
so
yeah.
A
This
is
interesting
because,
like
let's
say
that
you
had
like
if
you-
and
this
would
be,
this
would
be
another
interesting
thing-
I
wonder
if
if
this
would
be
something
that
would
be
a
good
addition
to
flux,
is
having
having
flux,
be
semver
aware
with
the
with
the
tags,
and
so
you
can
say
look
I
want
to
be
on
the
latest
version
of
1.2,
but
I
don't
want
to
be
on
the
latest
version
of
1.3,
of
whatever
utility
that
you're
doing,
because
you
do
have
this
situation.
You
see
this
happen.
A
All
the
time
in
github
release
is
where
github
shows
releases
based
on
on
date,
order
that
they're
applied
and
when
you
have
multiple
branches,
sort
of
seven
vert
I
pass
a
where
you
maybe
have
a
pre-release
type
of
thing
and
whatever
and
you're
doing
that,
with
with
the
same
set
of
tags,
then
the
same
image
stream
same
repo
order
based
on
time
is
not
the
order
you
want.
You
want
that
thing
to
be
sort
of
semaphore
aware,
and
then
that
would
be
another
piece
of
metadata
of
like
hey
look.
A
I
want
to
automate,
but
I
want
to
automate
within
this
sort
of
selector
of
ranges.
That
would
can
be
December
aware.
It
starts
to
look
a
little
bit
like
you
know,
dependency,
specifications
and
something
like
like
NPM.
You
know
package.json
type
things
so
that's
cool,
and
then
you
can
lock
the
controller
okay.
So
here
let's
go
ahead.
We
can
lock
this
and
I
think
what
this
means
is
that
locking
a
controller
will
stop
manual
and
automated
releases
that
controller
changes
made
to
then
the
file
will
still
be
synced.
So.
A
Ok-
and
this
has
locked-
it
actually
says:
okay,
here's
who
locked
it
well!
This
is
cool.
When
I
did
the
lock,
it
actually
recognized.
Who
did
it
I
wonder
why
it
doesn't
actually
use
that
in
the
commit
messages
when
it's
doing
other
stuff
too
right?
Because
I,
would
you
know
if,
if
flux
actually
knows
who
I
am
to
be
able
to
say
the
lock?
Why
didn't
it
do
that
when
I
actually
did
this
new
version
thing
here?
Alright?
Well,
ok!
So
so
now
we
can
do
new.
A
That
means
change
is
committed
by
a
person.
So
ok!
So
if
you
went
through
and
you
actually
edited
the
file
and
get
it
would
actually
go
ahead
and
do
that
so,
let's
let's
go
ahead
and
do
that
so
so
we
have
this
image.
Let's
take
this
one
that
we
want
to
do
that.
One
I'm
gonna
go
here
and
we're
going
to
like
we're
going
to
take
the
deploy
here,
I'm
going
to
edit
this,
because
this
is
how
I
roll
I'm
gonna
go
ahead
and
do
that.
Is
that
the
right?
A
That's
for
the
helloworld
one,
not
the
sidecar,
Yolo,
okay,
to
commit
directly
to
master
branch
and
now
what
should
happen?
Okay,
so
so
this
is
interesting.
So
so
there's
no
a
lot
of
times.
When
you
do
this
type
of
stuff,
you
want
to
set
up
a
git
hook
right
so
that
as
soon
as
you
make
changes,
it
goes
ahead
and
updates
that
I
don't
know.
Is
there
a
way
with
flux
to
actually
set
up
that
git
hook
so
that
it
actually
gets
notified
as
soon
as
possible?.
A
Yeah
so
that
I
think
that'd
be
interesting,
so
so
I
got
in
the
air
here.
So
as
no
changes
made
in
repo
and
that's
because
the
thing
was
locked,
I
think
okay,
so
there
are
get
hooks
and
that's
a
that's,
a
sort
of
like
it
more
advanced
config.
So
that
you're
not
you
know,
because
right
now,
you're
falling
back
on
polling
to
be
able
to
do
this
and
it
would
be
cool
if
I
could
do
sort
of
a
flux
control.
A
Is
there
a
way
and
then
I'd
also
love
a
command
which
is
just
like
sync
right
now,
like
actually,
you
know,
go
ahead
and
run
the
syncs
for
both
the
images
and
everything
so
I.
So
that's
good
for
demos
right
because
it's
like
hey
make
it
happen
right
now,
so
it's
sort
of
a
forced
sync
right
now
so
I'm
not
sitting
here
waiting
because
I
think
I
saw
that
at
least
with
the
reap
with
the
the
github
repo
stuff.
A
A
A
A
A
A
Do
the
port
forward
and
then
yeah?
Let's
do
the
export
again.
I
shouldn't
have
to
change
it,
but
and
I
did
redo
the
port
forward,
but
for
some
reason
it's
not
working
and
you
know
what
I'm
seeing
here
is
that
the
okay,
you
know
what
do
I
have.
Oh
you
know
what
I
did
the
wrong
port
forward.
Sorry,
that's
my
mistake.
A
Okay,
so
this
is
all
me
port,
because
I
did
the
I
did
the
one
when
I
was
trying
to
talk
to
the
hello
world,
so
there
we
go
now
we
got
that
going
and
now
I
can
do
flux,
control,
identity.
Okay,
we
got
that
up
and
running,
and
this
thing
is,
it
ends
with
three
PE
I.
Don't
know.
Well,
let's
see
so
now,
if
I
do
a
now,
the
question
is,
though,
it
still
says,
get
repo,
not
ready
and
I'm,
not
sure
what
that
means.
A
A
A
So
now
so
it
did
the
unlock,
and
now
it's
actually
doing
a
refresh
and
all
that
cube
control
or
this
images.
So
now
it's
pointing
to
that
one.
So
it
looks
like
okay,
so
the
upstream
URL,
so
upstream
URL
means
the
connection
to
we've
cloud.
Okay,
so
it
looks
like-
and
this
is
the
thing
that's
confusing
me
and
maybe
I'm
wrong.
A
Maybe
the
documentation
is
wrong,
but
it
says
so:
I'm
locking
a
controller
I
think
also
means
that
it
won't
apply
any
changes
that
you
make
manually,
even
though
it
says
changes
made
in
the
file
will
still
be
synced,
so
it
could
be
a
bug
going
on
there.
But
the
other
thing
is
is
that
you
know
if
there
is
a
mode
to
actually
put
an
annotation
on
a
deployment
that
says
hey.
A
So
so
you
know,
there's
this
I
think
there's
this
idea
of
what
are
the
objects
that
get
flow,
that
flux
is
pushing
and
then
what
are
the
objects
that
it
knows
how
to
manipulate
in
and
deal
with
like
controller,
so
I
think
controllers
are
a
subset
of
the
objects
that
flux
deals
with
and
in
doing.
Something
like
the
freeze
might
be
something
that
you
want
to
do
directly
on
the
object,
but
all
right.
A
So
that
looks
really
interesting,
also,
okay
and
then
and
then
there's
ways
that
you
can
let's
see,
issue
a
deployment
change
or
saw
the
inversion,
the
control.
So
that's
awesome.
We
saw
that
there's
flags
on
the
Dayman
so
that
you
can
change
all
of
this
stuff
here
and
then
it
says
when
building
images
is
often
useful
tag
build
images
by
the
branch
that
they
were
built
against.
A
A
So
you
know
even
if
it's
not-
and
you
can
do
that
on
a
per
pod
basis
versus
all
okay,
so
that's
pretty
cool
I
mean
on
a
per
per
image
basis
versus
all
so,
even
if
it
doesn't
totally
even
if
it
doesn't
go
through
and
understand,
you
know,
semver
I
think
it's
still.
You
know
you
can
get
a
lot
lot
with
this
globbing
we've
cloud,
you
I
sense
user
parameter
value,
which
is
the
you
name
of
the
user.
A
Login
we've
cloud,
okay,
so
the
upstream
service
does
stuff
and
then
actions
filtered
through
flux,
control,
so
flux
control
provides
following
flags
for
the
message
in
the
author
customization,
so
you
can
actually
specify
what
users
you
want
to
use
and
all
that
stuff
to
commit
author
all
right.
So
this
all
actually
makes
sure
that
that
the
the
get
the
the
get
history.
Actually,
it
looks
good,
that's
super
cool,
all
right,
well,
cool
all
right,
so
I
am
gonna,
wrap
off
I!
A
Think
that's
a
good
intro
to
how
how
flux
works
looks
like
a
super
cool
tool.
Let
me
switch
back
to
to
my
face
here.
Yeah.
The
tag
policy
definitely
seems
like
a
like
a
really
interesting
thing,
so
my
impressions
here
I
am
worried
about
the
security
of
this
stuff.
So
I
think
you
know
this.
This
suffers
from
some
of
the
similar
concerns
that
I
have
around
helm
in
that
there
is
a
there's,
there's
a
port
that,
as
far
as
I
could
tell
doesn't
look
to
be
authenticated
that
lets
you
manipulate
things
in
a
meaningful
way.
A
A
One
thing
that
could
happen
is
what
you
could
do
is
you
could
win
when
if
you
just
want
to
do
some
level
of
authentication,
you
could
go
through
and
have
the
flux
daemon
when
it
creates,
create
a
token
store
that
in
a
secret
and
then
anybody
who
has
access
to
that
secret
can
then
be
you,
as
you
know,
communicate
to
that
and
then
use
TLS
on
top
of
that.
So
you
could
do
some
stuff
with
that.
I
think
that
would
be
really
cool.
A
That's
totally
in
the
in
the
git
repo
there's
different
sort
of
philosophies
on
that,
but
then
again,
when
you're
manipulating
this
stuff.
Sometimes
you
don't
want
to
manipulate
the
animal
directly.
You
want
to
manipulate
some
other
file.
That
then
knows
how
to
actually
have
that
stuff
come
through.
So
having
some
sort
of
extensibility
mechanism
for
saying
list
me
all
the
the
components
list
me,
the
the
the
images
and
those
things
and
then
being
able
to
modify
those
I
also
think
that
as
we
CCR
DS
flux
can
go
through
and
push
CR
DS.
A
That
may
actually
include
controllers
to
actually
have
flux,
be
able
to
deal
with
that
in
the
flexible
way,
not
an
easy
problem
at
all,
and
then
Ilya
says
that
we
are
looking
how
it
would
work
with
generators,
yeah,
so
I
think
that's
definitely
a
challenge
and
super
cool
yeah
all
right.
Well,
thank
you.
So
much
Elliot
for
joining
us
I
know
that
it's
late
there
and
I
really
appreciate
you
taking
the
time.
I
think
it
was
definitely
it's
always
great.
A
When
I
do
these
things
to
have,
somebody
actually
knows
what
they're
doing
that
actually
stays
on
the
line
and
helps
answer
questions.
So
if
you
liked
this
I'm
going
to
sign
off
right
now,
please
hit
the
subscribe
button.
If
you
want
to
be
notified
when
we
schedule
new
things
or
when
things
are
happening,
there's
like
a
bell
that
you
can
put
there.
Also
that
says,
I
want
to
subscribe
to
notifications
other
than
that.
A
A
You
know
chief
keyboard
officer
whose
things
are
gay,
taking
more
and
more
of
my
time,
and
so
you
know
probably
you
know
I'll
find
a
way
to
to
work
with
Chris
and
find
the
right
schedule
so
that
we
can
both
still
participate,
but
but
it
doesn't
take
up
so
much
of
my
time
so
so
look
forward.
I
think
next
week,
I'm
definitely
signing
Chris
up
to
do
next
week.
So
look
forward
to
TGI
K
from
Chris
next
week
and
thank
you
every
from
buddy
from
Joe
for
joining
me
and
have
a
great
night
slash
morning.