►
From YouTube: Clean Up Your Room! What Does It Mean to Delete Something in K8s - Aaron Alpar, Kasten
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe 2021 Virtual from May 4–7, 2021. Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Clean Up Your Room! What Does It Mean to Delete Something in K8s - Aaron Alpar, Kasten
While issuing a `kubectl delete` and hoping for the best might work for day-to-day operations, having the knowledge of how Kubernetes effects deletes allows you to understand why some objects linger after deletion. This talk will cover how to delete objects, and what kubernetes does to coordinate the delete process. Some specifics of deleting pods, persistent volume claims, deployments and stateful sets will be covered.
https://sched.co/ek9i
A
A
A
My
background
as
an
engineer
is
mostly
in
custom
database
implementations,
domain,
specific
database
database
implementations
for
order
matching
dating
websites,
biological
analysis
and
geodesics.
So
today
I'm
going
to
be
talking
about
delete
which
can
be
difficult.
Specifically,
I'm
going
to
be
talking
about
what
properties
on
a
resource
can
govern
deletion.
A
The
two
things
I'm
going
to
focus
on
are
finalizers
and
owner
references
and
I'll
get
into
the
details
on
how
these
two
things
can
affect.
Deletion
of
objects
within
kubernetes,
I'm
going
to
demonstrate
how
it
works,
and
this
is
going
to
be
a
short
presentation.
So
I
have
30
minutes
plus
q
a
so.
The
goal
here
is
to
inform,
inspire
and
make
you
dangerous.
I
encourage
you
to
take
what
you
learn
here
and
experiment
with
it
on
a
test
cluster,
so
kubernetes
has
a
lot
of
commands.
A
Of
course,
I'm
going
to
be
focusing
on
delete,
I'm
going
to
be
using
four
cube,
cuddle
commands
throughout
this
presentation.
I'm
going
to
be
using,
create
get
patch
and
delete
to
keep
things
simple.
All
of
my
examples
are
going
to
use
config
maps
and
the
entire
presentation
is
basically
going
to
be
presented
as
a
series
of
shell
commands.
So
the
idea
is
to
give
you
the
commands.
A
Show
you
how
they
work
or
what
their
repercussions
are
results
are
and
to
give
you
some
examples
that
you
can
take
back
and
try
for
yourself.
So
here's
the
basic
delete.
All
my
shell
commands
are
in
bold.
The
output
for
those
shell
commands
is
the
lines
immediately
following
and
unbolded
unbolded
letters
here,
you
can
see
you
see,
I've
got
a
cube,
cuddle
create
config
map
my
map.
A
A
This
is
the
basic
delete.
It
is
very
simple:
we
start
off
with
a
cube
cuddle
create
which
creates
a
live
object.
I
then
perform
a
cube,
color
delete
which
deletes
the
object
and
it's
basically
the
final
state
for
the
state
diagram.
This
is
a
this.
Is
a
state
diagram
I'm
going
to
have
one
more
of
these
within
the
presentation
to
basically
explain
to
you
how
finalizers
work
so
finalizers
finalizers
are
resources
on
our
our
finalizers
are
keys
on
resources
that
control
their
garbage
collection?
A
A
A
Kubernetes
finalizer
is
a
dead
finalizer
for
configmat.
A
config
map.
Resource
controller
doesn't
understand
what
to
do
with
this.
At
least.
As
far
as
I
know,
kubernetes
finalizer
is
actually
used
on
namespaces,
so
this
is
going
to
produce
some
interesting
results.
So
here
I'm
going
to
create
this
config
map.
A
A
A
A
A
A
A
A
A
A
And
here's
basically
a
slide
that
says
what
I
just
said,
keep
in
mind:
finalizers
are
just
keys.
They
should
be
managed
by
the
controllers,
but
they're
not
always
managed
by
the
controllers,
especially
in
the
case
of
dead
finalizers.
That
I
just
showed
you
here
are
some
common
finalizers
that
you've
probably
seen
at
least
the
ones
I
certainly
come
across.
Most
often
are
the
pv
and
pvc
protection
finalizers
they
they're.
A
They
are
there
to
govern
the
deletion
of
the
resources
that
are
in
the
back
of
kubernetes,
the
actual
disks
themselves
and
the
actual
reservations
on
the
disks
themselves.
There's
kubernetes
finalizers,
which
is
used
in
namespaces
and
there's
a
foreground
deletion
which
I
will
allude
to
a
little
bit,
but
I
won't
get
into
it
in
depth.
A
So
that's
it
for
finalizers,
finalizers,
basically,
control
how
a
single
object
is
deleted
by
the
controller,
so
owner
references
tell
how
groups
of
objects
are
deleted.
Owner
references
are
properties
on
resources
that
specify
the
relationship
to
one
another,
so
entire
trees
of
resources
can
be
deleted.
A
Finalizers
rules
are
processed
when
there
are
owner
references,
so
these
are
not
they're
somewhat
orthogonal
on
how
they
work
and
you've,
probably
already
seen
these
on
pods
pods
typically
have
owner
references
to
their
replica
sets.
So
when
the
deployments
stateful
sets
or
replica
sets
themselves
are
deleted
that
the
pods
are
taking
care
of
the
process,
I'm
going
to
show
you
a
quick
example
of
owner
references
and
how
they
work.
I'm
going
to
start
off
with
a
really
simple
example
and
then
I'll
work
into
progressively
more
complex
examples.
A
Here,
I'm
going
to
create
my
parent
object
first,
since
the
references
are
from
child
to
parent,
I
have
to
create
the
parent
first
and
then
I
can
go
ahead
and
create
the
child.
Here
I
have
to
do
some
shellfoo
to
get
the
uid
out
of
the
parent
and
included
in
the
child,
and
you
can
see
that
once
again
we
have
a
very
simple
config
map
that
contains
an
owner
reference
to
its
parent,
an
owner.
Reference
consists
of
a
name
and
a
uid
owner.
A
A
You
can
delete
the
child
and
when
an
over
reference
is
involved,
the
deletion
of
a
child
typically
doesn't
really
do
anything,
or
rather
the
the
child
will
be
deleted,
but
nothing
will
do
will
be
done
with
a
parent
things
get
interesting
with
deleting
the
parent
owner.
References
really
change
how
trees
of
objects
are
deleted
from
their
parents.
So
here
we
create
the
parent
child
references
in
the
config
maps.
A
A
A
A
Now
this
cascading
property
can
can
change,
it
can
be
the
the
cast.
There's
the
cascade
option
on
the
delete
can
be
specified
to
basically
allow
you
to
orphan
children,
so
you
can
delete
a
parent
without
actually
deleting
the
children.
If
you
delete
the
parent
with
a
delete
command
using
cascade
equals
false.
A
What
it
will
do
is
it
will
take
the
owner
references
off
of
the
children
but
leave
the
children
intact.
There
there's
something.
That's
also
called
propagation
policy
which
the
cascade
option
links
to
which
controls
the
order
in
which
the
the
order
in
which
the
nodes
in
the
order
in
which
the
nodes
in
the
tree
are
deleted.
A
A
A
My
parents,
you
remember
earlier
this
deleted
when
I
ran
this
without
a
cascade
option.
It
deleted
the
entire
tree
here
I'll
go
ahead
and
delete
the
parent
with
cascade
equals
false.
It's
come
back
with
exactly
the
same
responses.
I
got
before
config
map
my
map.
Parent
has
been
deleted,
but,
as
we'll
see.
A
A
This
is
done
by
setting
the
what
happens
in
the
back
end
is
the
propagation
policy
when
you,
when
you
specify
cascade
false,
is
it
sets
the
propagation
policy
for
the
api
call
and
that's
what
we'll
be
looking
at
next
propagation
policy
allows
you
to
change
the
order
in
which
objects
are
deleted
within
a
tree.
Propagation
policy
cannot
be
specified
on
the
command
line
with
kube
cuddle
other
than
orphaning
objects.
A
A
A
I
will
show
you
this
running
on
the
examples
that
I
have
in
just
a
moment.
This
is
a
background,
propagation
policy.
This
sets
the
order
to
delete.
I
delete
from
parent
to
child,
so
there's
three
there's
three
different
options
for
the
propagation
policy:
there's
foreground
deletion,
which
is
the
post
order,
deletion
or
you
can
specify
a
background
deletion,
which
is
a
pre-order
deletion
foreground
is
children
are
deleted
before
the
parents
are
deleted
background.
Is
parents
are
deleted?
First,
a
parent
is
deleted
before
their
children.
A
A
A
A
A
A
A
It's
then
you've
got
a
at
that
point.
You
have
to
dig
in.
You
have
to
look
at
the
existing
owner
references
on
your
objects
with
some
knowledge.
If
the
owner
references
have
been
deleted,
what
they
were
before,
as
well
as
the
finalizers
to
understand
what's
happening
there.
The
once
again
the
goal
here
is:
give
you
the
tools
to
figure
that
out
so
there's
an
exercise
that
you'll
have
to
go
through
to
do
a
little
bit
of
research.
A
A
This
is
a
basically
if
you've
deleted
a
namespace,
you've
cleaned
out
all
of
the
objects
under
it,
but
yet
the
namespace
still
exists.
Here's
the
command
to
force
the
finalization.
This
is
one
of
the
reasons
why
I
showed
you.
The
right
pi
calls
before
this
there's
a
there's,
an
api
call
off
of
off
off
of
the
namespace
called
finalize.
A
A
So
so,
thus
concludes
the
presentation,
so
you
take
away.
Takeaways
from
this
are
finalizers
can
get
in
the
get
in
the
way
of
the
deletion
of
resources,
especially
when
there's
trees
involved
of
owner
references
generally,
there's
a
reason
for
a
finalizer's
presence.
You
should
investigate
first
before
manually,
deleting
it
owner
references,
allow
trees
of
resources
to
be
removed,
specified
and
removed,
and
once
again
finalizers
are
honored
in
that
process.
So
they
can,
they
can
result
in
partial
deletion
of
partial
deletion
of
trees.
A
Propagation
policy
can
be
specified
in
a
custom
api
call
to
change
the
order
in
which
resources
are
delivered
deleted.
So,
if
you're,
in
a
situation
where
you
do
have
a
partial
tree,
you
can
control
how
those
objects
are
deleted
by
specifying
the
propagation
policy
on
the
api
call.
So
here
are
some
additional
references.