►
From YouTube: 2020-07-16 Cassandra Kubernetes SIG
Description
Zain Malik from the Kudo project gives us a preso on the work they are doing on making operators easier. Lots of great discussion.
A
All
right,
we're
recording,
and
so
today,
in
the
sig,
so
john
sander
he
last
minute
he
can't
make
it,
but
I
think
he
gave
us
he
sent
an
email
which
I
think
is
worth
talking
over
about
getting
started.
But
we
have
zane
malik
here
who
asked
to
asked
to
quickly
talk
and
he
had
an
agenda
item.
He
wanted
to
talk
about
the
project
he's
working
on,
and
so
I
would
thought
it
would
be
great
to
considering
like
what
that
project
does
and
what
it's
about
for
operators.
A
I
thought
it'd
be
great,
you
know,
and
just
in
the
spirit
of
open
source
inclusiveness
and
trying
to
figure
out
how
we
can
work
better
with
the
project
it'd
be
great
to
hear
about
what
zane
is
working
on
so
zayn.
If
you
want
to
take
it
away
and
talk
about
kudu,
I
think.
B
Yeah
sure
thank
you,
patrick's
and
thank
you
for
adding
the
item
on
last
minute,
so
I'm
work
me
android
and
mathias.
Now
he
just
joined.
We
are
working
on
a
guru
project
and
kuro
just
got
into
like
cnc
of
sandbox
during
last
last
week
or
two
weeks
ago.
So
we
are
right
now,
if
you
don't
know
about
kuro
you
can
like
I.
I
will
do
like
a
really
brief
review,
like
about
what
the
guru
is
doing,
but
that
won't
be
the
main
focus
here.
B
Our
main
focus
right
now
is
like
how
we
can
like
works
towards
like
helping
open
source
community
building
like
production
grade
operators.
In
that
sense-
and
I'm
not
just
dropping
in
here
for
the
cassandra
sick
meeting
our
joining
few
meetings
I
joined,
so
we
will
take
kudos
and
we
were
trying
to
you
know
like
align
with
the
community
in
that
sense
right.
B
So
here,
in
the
last
meetings,
jim
mentioned,
like
maybe
kudo,
could
be,
like
you
know,
evaluated
for
building
a
community
operator
in
that
sense,
and
so
I
was
working
on
trying
to
find
from
my
perspective
what
would
be
gaps
there
and
trying
to
fill
in
those
feature,
gaps
and
try
to
present
like
this
is
now
driven
by
like
the
cassandra
community
needs
right.
So
let
me
just
share
my
screen
and
we
will
go
through
like
three
small
topics.
So
first
we'll
be
like
what
is
kudo.
Second
is
like
I
will
introduce
kuroshim.
B
That
is
like
experimental
project
that
basically
is
driven
for
cassandra
community
and
the
third
is
just
an
example,
a
demo
for
the
of
kudo
cassandra,
but
basically
it
will
be
using
a
generic
crd
to
install
cassandra.
Let
me
just
share
my
screen.
B
The
operator
is
like
basically
defined
into
like
some
part
like
driven
by
like
we
haven't
charged
in
that
sense,
but
it
goes
way
beyond
that.
What
the
hand
charts
are
doing-
and
we
have
like
three
crds
that
are
like
operator
version
operator
and
instance
right,
so
those
are
defining
the
the
architecture
of
the
guru.
So
if,
for
example,
if
I
want
to
install
like,
like
kuroko
operator,
I
have
to
just
define
my
operator
operator
version.
B
These
are
like
in
the
example
structure
like
kubernetes
object,
and
when
I
create
an
instance,
it
will
automatically
create
a
workload
that
is
related
to
what
is
the
operator
developer
of
kudu.
Kafka
has
defined
right,
so
kudo
controller
is
watching
this
crds
and
it
will
you
know
I
just
create
that
so
this
this
is
one
approach
to
standardize,
creating
the
operators,
and
I
don't
want
to
really
go
deep
into
that
part.
B
So
we
wanted
to
contribute
on
that
sense
and
in
that
sense,
like
kudos,
crds
are
just
operator
operator
version
instance
right,
so
there's
no
cassandra,
dev,
spec
or
cassandra.
You
know,
like
crd
spec,
that
when
I
saw
it
was
lacking,
we
started
developing
some.
You
know
like
to
fill
in
that
gap,
so
at
least
we
can
be
evaluated,
as
a
part
of
you
know,
like
it's
reliable
solution
for
delivering
a
community
operator.
B
B
So
when
it's
happening
like
when
we
are
installing
a
typical
kudo
operator,
we
are
installing
liquid
instance
here
and
will
you
know
I
create
all
the
related
workloads
and
the
all
the
kubernetes
objects
in
the
end,
for
that
are
necessary
to
make
this.
You
know
like
workload
healthy
for
we
are.
We
just
did
one
thing.
That's
called
kuroshim.
Shim
is
basically
the
idea
about
a
like
dynamic
crd
controller
or
generic
crd
controller,
where
his
shim
controller
is
watching
in
like
a
shim
instance
that
has
actually
defined
the
crd
spec
and
it's
kickstarter
generic
crd
controller.
B
That
really
we
start
watching.
You
know
like
the
crd
that
we
have
defined.
I
want
our
shim
instance
in
this
case
like
I.
If
I
want
to
call
my
crd,
my
dot
kafka
dab
like
and
some
api
version,
v1
alpha,
one
would
be
one
better
one
that
will
be
so.
We
can
define
the
behavior
of
the
life
cycle
of
the
operator
in
my
crd,
and
it
will
be
actually
mapping
that
behavior
into
a
good
operator
right.
So
we
could
go
ahead.
B
The
guru
community
could,
just
you,
know,
go
ahead
and
use
that
crd
and
like
just
replicate
that
behavior
in
the
kudo
cassandra,
so
we
could
say,
like
we
are
compliant
with
the
cassandra
community
crds,
but
a
main
drive
behind
that,
and
also
to
help
like.
If,
because
our
community
is
doing
an
effort
to
come
forward
and
be
a
cr
spec,
we
should
not
put
on
the
table
for
the
cassandra
community
that
the
only
way
going
forward
is
using
the
kudos
crd
spec
right
so
define
the
whole
spec.
B
So,
if
somebody
has
like
some
questions
about
design
about
kudo,
I
will
take
a
pause
here
before
jumping
into
demo,
and
I
would
like
to
answer
that
and
later
I
would
like
to
show
one
of
the
few
examples,
because
one
example
that
was
done
is
the
cassandra
we
are.
Basically,
we
are
taking
the
datastax
crd
spec
to
actually
create
a
kudo
cassandra
instance
right.
B
Basically,
kudo
cassandra
is
right
now
because
it's
available,
but
could
be
any
community
like
operator
in
that
sense,
and
data
set
crd
because
we
believe
like
this
is
where
the
community
will
go
and
when
the
still
we
don't
have
any
community
crd.
So
we
just
opted
to
take
the
dollar
stack
crd
just
to
like
do,
for
example,
or
demo
here.
D
It's
it's
been
from
it's
cluster
here
so
with
with
the
shim
just
to
make
sure
I've
got
this
around
the
right
way
of
my
head,
the
you're
translating
the
the
the
community
spec
or
the
kudo
spec
crd
and
then
generating
a
data
stacks
crd,
which
then
the
the
data
stacks
operator
then
goes
and
takes.
You
know,
provisions
and
does
ownership
of
that,
so
that
the
developer
is
just
interacting
with
that
one
common
crd,
but
it
could
be
potentially
any
operator
on
the
back
end.
B
So
here
is
the
shim
instance.
We
are
saying,
like
you
know,
like
which
good
operator
to
actually
install,
but
in
the
crd
specs
we
are
like
telling
them
which
crd
to
watch-
and
here
are.
You
know
like
just
an
example
of
a
sexy
already
but,
for
example,
some
pieces,
I'm
putting
you
on
like
these
are
not
defined
here.
So
this
node,
mib
or
node
counts
are
basically
the
parameters
to
the
kudo
operator
right.
B
So
users
can
actually,
you
know,
go
ahead
and
not
use
it,
but
the
operator
developers
they
can
go
ahead
and
write
their
operating
declarative
approach
without
knowing
about
control,
runtime
or
reconcile
cycles
or,
like
writing,
the
all
that,
like
extra
code,
that
is
necessary
to
write
an
operator
so
when
the
users
come
so.
A
D
C
D
B
Yeah,
this
is
the
spec
that
they
would
be
writing.
It
would
be
exactly
like
what
would
be
the
writing
for
dollar
stacks
operator
right.
So
here
they
are,
writing
just
size
two.
They
don't
have
to
know
about
the
underlying.
You
know
like
implementation
details
or
what
is
going
on.
They
would
just
be
like.
I
want
a
cassandra
data
center
of
you
know
like
the
taxi
api
version,
and
size
is
two
because
I
need
like
a
two
node
customer
cluster
and
memory
is
like
512
right.
D
B
So
the
point
is
like
the
end
users,
they
should
be
just
you
know
like
interacting
with
the
community
crd
or
in
that
case,
cassandra
are
sexy.
Are
you
right?
So
they
don't
have
to
learn
how
kudo
cassandra
operator
works.
How,
like
you
know
like
gas,
cops
work
or
how
other
works?
The
whole
idea
is
like
the
same
crd
can
be
implemented
in
different
ways.
Right.
D
A
This
is
so
ben.
I
think
you
you
know
I
may
be
thinking.
The
same
thing
is
this:
is
this
is
a
way
to
have
multiple
operators
out
there
with
a
more
like
and
and
correct
me
if
I'm
wrong
zayn?
Is
it
this
this?
You
would
only
the
you're
like
if
you
were
fully
like
kudo
is
your
path
you're
using
it
in
your
kubernetes
cluster.
You
don't
have
any
other
operators,
you
have
a
kudu
operator
and
the
kodu
operator
it
just
assumes
all
the
crds
from
anything
else
that
you
need
is
that
right.
A
B
Yeah
so
yeah
like
that
would
be
like
we
probably
don't
have
to
talk
about
shim
to
you
know
like
answer
that
question,
because
shim
is
actually
trying
to
fill
some
gap
between
kudo
and
the
like
rest
of
the
crd
specs,
but
what
kudo
is
like
trying
to
fill
in
is
like
if
I
want
to
like,
like
kick
start
my
operator
and
I'm
coming
from.
Let's
say
kafka
background
right
and
I'm
very
really
expert.
B
I
have
a
lot
of
expertise
in
kafka
and
now
I
have
a
built-in
workload
on
top
of
kubernetes
for
kafka,
and
I
want
to
build
my
kafk
operator
then.
First
I
need
to
learn
like
operator,
sdk
or
queue
builder,
or
you
know
like
control
runtime.
Then
I
need
to
know
like
I
have
to
know
about
the
goku
language.
I
have
to
learn
the
go
code.
B
Then
I
have
to
know
how
to
test
those
operators
right
like
if
what
I
am
writing
and
I
have
to
know
a
lot
of
deep
knowledge
around-
writing
operators
best
practices
in
the
on
top
of
kubernetes
right.
So
there's
like
a
kind
of
a
gap
between
from
where
a
workload
based
tech
expert
could
kick
start
writing
their.
B
If
it's
you
want
to
publish
it,
if
it's
for
internal
use,
it
will
still
take
time
and
a
lot
of
iterations
to
get
it
right,
and
if
what,
if
you
want
to
do
it
with
the
help,
it's
like
home
is
lacking
a
lot
of
lot
of
features
that
would
make
it
a
operator
complete
and
that's
where
we
are
trying
to
fill
in
a
gap
where
we
are
not
like
quite
like
in
the
helm
you
know
like.
But
we
are
also
like
filling
gap
where
the
upper
sdk
is
like
trying
to
fill
the
gap.
B
But
there's
like
a
huge
gap
in
there,
where
they
can
actually
start
writing
and
pushing
it
to
the
to.
You
know
like
pushing
it
to
a
kubernetes
cluster,
and
I
think
like
here,
if
I
would
let
like
matias
or
andreas,
if
they
want
to
say
something.
But
it's
it's
like
really
has
been
like
a
huge
work
from
you
know
like
kudo
team,
on
that
sense
like
where
we
are
trying
to
find
and
build
in
the
gaps
for
writing
easily
the
workloads
on
top
of
kubernetes.
E
Without
the
overhead
of
like
go
and
the
go
ecosystem
and
a
fully
fledged
programming
language
and
in
a
more
declarative
way,
feels
more
like
helm
than
programming
go,
I
guess,
and
you
can
get
I
guess
most
of
it
done.
So
that's
that's.
Basically
the
short
version
of
it.
A
I
so
I
was
just
talking
to
somebody
last
week
about
how
operator
hub
is
showing
like
this
explosion
of
operators.
It's
almost
becoming
too
much
right
is
this.
Is
this
an
attempt
to
try
to
get
that
under
a
better
way,
try
to
find
it
better
way
than
4
000
operators?
As
a
matter
of
fact,
there's
operators
for
operators
now
so
which
you
know,
is
kind
of
we're
starting
to
do
this,
because
they're
now
operators
for
operators,
but
that's
not
what
this
is
right.
E
We
have
that
in
mind.
I
guess
it
comes
up,
but
it's
it's
not
really
in
the
focus
at
the
moment.
D
D
You
know,
I
guess
in
in
my
mind
the
mental
model
for
operators
was,
you
know
for
a
given
well-defined
piece
of
technology
genuine
genuinely
there
should
only
you
know
be
one
for
any
well
well
implemented
definition,
you
know.
So
I
I'm
I'm,
I'm
just
trying
to
understand
you
know
in
the
community.
Do
you
see
people
going?
Oh
well,
hey
that
implementation's
not
right.
I
need
to
write
my
own
and
so
having
an
easy
framework
to
do.
That
is
a
benefit.
E
Well,
I
guess
the
the
benefit
of
having
the
easy
framework
is
the
maintenance
overhead
to
like
keep
the
maintenance
low,
because
I
guess
it's
the
same
with
any
other
software
like
like
backup
tools
for
cassandra
or
backup
tools.
For
other
databases,
you
you
have
like
three
or
four
or
five
projects
on
github
and
probably
one
of
them
gets
most
traction
and
the
other
ones
trail
off.
At
some
point,
I
guess
it
will
be
the
same
as
operators,
I
guess,
what's
complicated.
E
A
Does
it
manage
dependencies
in
that
as
well
or
will
it
help
with
dependency
management,
because
this
is
another
pain
point
that
I've
discussed
with
a
few
large
operators
is
that
our
operators
are
colliding,
and
is
this
a
way
to
solve
that
problem
as
well.
B
Yeah
languages
implemented
a
good
operator
task
like
actually
when
you're
writing
a
good
operator.
You're
writing
like
a
bunch
of
tasks
that
needs
to
be
done,
so
it
can
be
applied,
delete
like
pipeline
task
or
toggle
task,
and
one
of
the
tasks
is
actually
good
operator
does
so
you
can
actually,
you
know,
like
bundle
another
operator
inside
the
operator,
so
that's
kind
of
how
we
solve
the
dependencies
and
we'll
try
to
resolve
the
dependency
and
install
it.
So,
let's
say
for
kafka.
B
I
need
zookeeper
right,
so
this
is
like
a
dependency
like
we
would
like
to
solve
with
kudo,
and
this
is
like
where
I
have
like
just
two
things
like
first
like
coming
back
to
like
then
said
like,
if
we
we
are
seeing
a
lot
of
same
spec,
crd
being
implemented
different
times
with
a
lot
of
you
know
like
different
developers.
B
I
this
is
not
the
case
that
we
wanted
to
present
here,
like
we
are
doing
actually
this,
because
the
community
is
coming
up
with
the
crd
right
and
we
don't
want
to
tell
the
community
hey
guys
like
don't
do
this
just
use
a
kudo
operator
version
or
guru
operator,
and
it
will
work
well
right.
B
So
the
idea
is
like
each
community
should
be
independent
to
define
their
crds
right
and
there
should
not
be
any
limitation
from
the
kuru
side
that
I
cannot
build
a
good
operator
on
top
of
that
crd,
that
a
community
after,
like
a
lot
of
hours
of
work,
have
come
together
to
define
the
stack.
So
this
is
the
case
we
are
seeing
where
a
different
community
is,
like,
I
hope
kafka
does,
that
which
I
don't
seem
to
like
near
future,
mongodb
or
elastic.
B
B
B
B
So
with
this
we
are
trying
to
solve
from
you
like
already
from
day
zero,
like
you
know
like,
if
you
are
building
an
operator,
all
the
objects
that
are
being
created
by
this
operator
will
be
owned
by
you
know
like
the
this
instant
score
instance
and
then
later,
if
you
are
building
and
features,
we
have
like
toggle
tasks
or
other
helpful.
You
know
like
features
which
will
help
to
introduce,
like
iterative
way
of
you
know
like
development,
where
a
feature
is
added
or
removed,
like
you
know
like
in
a
kubernetes
style.
B
So
this
is
also
like
trying
to.
We
are
trying
to
help
with
like
developers
who
are
like
really
great
developers,
but
they
are
developers
for
other
technologies
right,
but
then
they
want
to
be
bring
their
workload
on
top
of
kubernetes.
So
that's
also
like
one
gap.
We
are
trying
to
fill
with
the
this
kudo
approach.
F
Can
I
ask
a
question:
this
is
eldon
from
from
data
stacks?
Did
you
were
there
specific?
Did
you
look
into
the
the
operator,
sdk
ansible
or
helm
operator
deployments
at
all
and
kind
of
like
what
were
the
primary
issues
that
you
you
viewed
from
from
those
operator,
sdk
deployment
strategies.
B
Yeah
like
so,
this
has
been
coming
up,
not
like
now
like
it's
like
it
has
been
like
in
development
from
like
almost
a
year
and
a
half
now
like
kudo,
so
back
at
that
day,
like
it
was
already
like
quite
established,
and
we
know
like
how
to
build
operators,
but
the
main
point
was
like
helm
was
too
less
for
us.
If
we
want
to
get
requested
like
complex,
you
know
like
workflows
on
top
of
kubernetes.
Home
is
basically
yeah
like
just
create
this
and
just
delete
this
right.
B
B
I
need
to
know
like
what
are
the
kubernetes
basic
concepts
and
I
need
to
learn
about
them,
and
the
entry
level
like
like
into
the
kubernetes
world
is
like
really
huge
in
that
sense
like
if
you
look
at
the
first
of
few
operators
like
it
can
go
from
like
2000
lines
of
code
to
you,
like
maybe
hundred
thousands
of
codes
like
if
they
depend
on
the
complexity
of
the
operator,
and
we
are,
we
are
like
entering
into
kubernetes
world
where
kubernetes
is
trying
to
like
mark
it
as
a
declarative
approach
to
like
run
the
workloads
and
easier
for
you
know
like
the
developers
who
are
actually
building
the
applications,
they
can
run
those
applications
on
top
of
kubernetes
with
the
deployment
or
you
know,
stateful
set
or
the
service
you
like.
B
So
these
are
all
objects
that
are
helping
the
developers.
But
if
you
want
to
build
an
operator,
then
yeah,
you
have
to
certainly
learn
a
lot
of
few
more
other
concepts
and
don't
really
feel
with
any
of
those
concepts,
because
you
know
like
that
could
be
like
really
disaster
for
your
production
deployment.
In
that
sense,
right-
and
we
also
see
like,
for
example,
examples
of
elastic
operator
that
they
were
just
running
with
ports
like
in
like
without
any
stateful
set,
and
they
have
to
just
rewrite
all
the
things
back
to
stateful
set.
B
So
there
was
like
you
know,
like
a
lot
of
breaking
changes
in
that
sense,
and
we
just
want
to-
and
this
can
happen
also
with
the
other
operators
right
like
when
you're
writing,
and
it's
your
first
time
and
you
don't
like
hit
the
right
but,
like
you
know,
like
writes
back
and
then
you
have
to
rewrite
it
again.
So
we
are
trying
to
you,
know,
lower
that
barrier
and
make
it
easier
for
writing
operators.
B
B
Yeah
so
like
this
is
like
just
one
of
the
few
features
we
have
been
asked
like,
so
we
don't.
We
don't
have
enough
feedback
for
that.
So,
if
somebody
wants
to
say
like
I
want
to
use
help
mobile,
like
you
know,
like
help
jordan,
let
we
are
open
to
you
like
build
that
and
like
work
on
that,
but
as
for
another,
there
has
not
been
enough
feedback
or
people
asking
for
that.
Like
hey,
I
want
to
use
help
as
a
dependency
right
in
my
operator
or
ansible.
In
that
case,.
G
G
So
I
would
have
been
interested
if
you
had
you've
taken
the
the
crd
that
we
have
been
working
with
jim
to
to
basically
describe
the
new
crd,
see
that
we
are
trying
to
agree
on
because
we
all
have
cut
already,
and
I
would
like
to
know
because
the
thing
is
why
we
did
develop
an
operator
for
cassandra.
Was
that
because
customer
is
difficult
to
operate,
so
you
have
to
be
able
to
do
really
touchy
things
at
different
times
to
for
cassandra
to
operate
in
communities.
G
It's
I'm
not
sure
there
are
hardest
things
to
to
run
on
cassandra.
Don't
communities
in
kassandra!
So
can
you
show
us
how
you
do?
Oh,
you
would
say
that's
the
the
task
I
need
to
run
when
I
do
a
scale
down,
for
example,
when
people
change
the
crd
and
change
from
four
three
to
two
nodes.
How
do
you
describe
in
your
kudo?
G
What
are
the
operations
to
be
done
on
which
node
and
not?
In
which
sequence
I
mean
there
are
loads
of
things
that
are
very
difficult
in
cassandra.
I
mean
to
just
to
to
start
a
cluster
with
four
nodes
with
a
basic
image.
It's
pretty
simple,
but
that's
not
you
talk.
You
talked
about
production
time
times.
Production
in
times
of
production
is
with
the
hardest
bits
coded,
not
the
easiest.
You
see
what
I
mean.
B
Yeah
so,
like
I
think,
like
we
have
already
like
kuroko
sandra
out,
so
it
has
a
lot
of
features
in
that
sense
and
I'm
like
we
are
not
trying
to
say,
like
everything
has
to
be
like
inside,
like
decorative
yaml
and
the
complex
workloads
cannot
be
done
here.
So
what
I
would
give
you
an
example
just
like
even
like
for
a
even
more
complex
that
is
evicting
nodes
right.
So,
for
example,
when
we
are
doing
this,
let's
say
like.
B
I
have
like
a
note
lost
in
guru,
kasana
like
in
a
cassandra
cluster
right
and
the
local
storage.
We
are
using
local
storage
in
that
sense
right,
I'm
not
talking
about
like
a
aws
ev,
a
csci
driver,
but
for
local
storage.
B
When
it's
totally
gone
and
we
you
know
like
the
nodes,
new
nodes
comes
up
like
if
it
comes
up,
it
will
join
up
at
the
new
node
right,
but
the
thing
is
like
with
the,
for
example:
it
will
change
the
ip
also
right,
so
we
have
to
tell
somehow
the
kudo
kasana
that
you
know
like
this
is
a
rejoining
the
node.
So,
in
that
sense
like
a
complex
operation,
so
right
now
like
no
other
operators,
not
even
data
stacks
like
supporting
that,
so
when
the
local
store
is
gone
and
it's
rejoining
it
right.
B
Foreign
cannot
detach
the
like
the
pvc
from
the
from
the
node,
so
till
some
manual
intervention
is
coming.
We
cannot
really
do
that
right.
So,
in
the
case
of
kudo
kasandra
like
what
we
are
doing
is
like,
we
have
a
another
controller.
That's
the
recovery
control.
That
is
just
basically
using
go
code
for
right
like
connecting
to
the
api.
So,
but
we
don't
have
to
know
about
reconcile
cycles
or
like
which
objects
we
have
to
reconcile.
B
So,
for
example,
we
have
one
thing
that
is
called
kasana
topology
right
so
in
in
the
start
it's
like
empty,
but
when
the
bootstrap
is
happening
right,
so
we
are
filling
it
with
the
kasana
port
name
and
the
ip
address
right.
So
we
are
making
sure
that
the
once
the
node
is
in
upstate
joining
or
normal.
It's
just
register
itself
like
I'm.
B
B
So
in
the
case
like
you
know,
if
it
has
a
replace
ip,
it
has
to.
You
know
like
this.
This
is
one
of
the
small
examples
right
like
where
we
cannot
replace
a
a
node
when
it's
itself
in
the
seeds
right.
So
first
we
have
to
remove
ourselves
from
the
seed,
because,
if
it's
coming
joining
the
cluster,
we
cannot
just
use
it
and
see
it.
So.
H
D
You
know
bash
code
like
this
kind
of
embedded
in
you
know
in
in
your
operator,
and
that
kind
of
thing
like
a
good
example
of
this,
is
you
know
when
we
first
implemented
support,
for
you
know,
t
you
know,
tls
between
cassandra
nodes
and
also
you
know,
client
to
client
to
node.
D
B
Yeah
so,
as
andres
said
like
we
are,
we
are
using
control
because
that's
another
declarative
way
to
you
know
like
to
test
the
kubernetes
operators
and
that
one
is
part
of
the
ecosystem.
So,
instead
of
like
testing
the
batch
code
and
like
the
lines
there,
we
are,
what
we
are
testing
is
the
kubernetes
objects
right.
So
we
are
testing
here
that
the
instance
is
complete.
For
example,
the
plan
is
complete
or
there
are
two
ready
replicas
for
cassandra.
E
And
to
to
be
honest,
that
is,
that
is
a
pain
point,
because
at
the
moment
a
full
test
run
is
like
one
and
a
half
hour
which,
which
is
quite
a
bit.
It
starts
like
I'm,
not
totally
sure,
but
I
guess
around
10,
maybe
15
cassandra
clusters
and
destroys
them,
so
it
takes
a
while
okay,
well
20
minutes
of
that
is
the
kubernetes
cluster
spin
up
and
spin
down.
But
it's
still
around
one
hour
for
for
the
whole
testing.
G
Testing
is
not
the
hard
part
is
when
you
have
a
problem.
How
do
you
debug?
Where
do
you
find
the
thing
I
mean
in
go
if
you
have
a
proper
defined
iide
with
telepresence
or
stuff,
like
that,
you
can
step
by
step,
debug
what's
happening
in
your
operator
within
kubernetes,
and
you
can
find
where
the
problem
is.
That's
well
to
be.
E
E
For
me
is
like
running
tests
and
getting
a
really
big
amount
of
locks
and
looking
through
that
and
analyzing
that-
and
I
guess
debugging
a
goal
operator
has
it
has
its
advantages.
E
I'm
I'm
not
sure
how
much
of
an
advantage
it
actually
is.
How
often
I
would
use
it.
B
But
yeah
like,
as
we
have
like
the
testing
over,
it
is
hard
so
like
this
is
another
way
that
we
want
to
make
sure
that
each
step
or
each
feature
we
are
doing
can
be.
You
know,
reflected
into
kubernetes
subject,
because
that's
how
you
should
develop
operators
on
top
of
kubernetes.
Is
that,
like,
let's
say,
if
I'm
creating
some
operations
that
are
not
like,
you
know,
like
super
base
stack
for
cassandra
to
do
a
repair,
but
if
it's
not
leaving
any
trace
on
any
kubernetes
subjects,
it's
not
really
like
a
kubernetes
adopted
operator.
B
In
that
sense
right,
and
for
that
let's
say
like
if
I
want
to
do
some
kind
of
you
know
like
a
config
map
of
the
kasana
topology
log,
if
it
was
last
updated
by
kasana,
not
zero.
That
test
for
us
is
like
a
better
adopted.
Then
just
go
and
you're
like
trying
to
find
a
place
to
test.
If
the
batch
script
is
exactly
doing
what
it
has
to
do.
There
are
still
like
places
that
we
have
to
say
that
we
are
not
like
you
know
like
anti-go.
B
In
that
sense,
we
we
have
tasks
that
are
in
go
of
course,
because
we
are
go
developers
also
right
so
because
we
have
built
scooter
on
top
of
go,
and
so
we
we
won't
choose,
but
we
want
to
give
a
choice
to
the
operators
if
they
want
to
work
like
do
that
in
you
know
like
in
in
python
or
something
like
where
they
feel
more
comfortable,
they
can
go
ahead.
You
know
I
can
just
write
their
touch,
for
example
this
for
the
external
service
of
the
cassandra.
B
B
We
write
our
stack
and
generate
it,
and
this
is
the
I'm
not
saying
this
is
the
wrong
way.
But
this
is
like
actually
doing
a
kind
of
acting
as
like
a
gatekeeper
for
the
other
developers
who
have
a
lot
of
other
expertise
and
they
could
like
really
contribute
to
kubernetes
ecosystem,
and
they
found
it
hard
to
do
that,
and
one
of
the
reason
that
we're
doing
that
is
basically
the
last
sig
meeting.
I
was.
B
I
want
you
to
talk
about
the
cuddle
like,
so
we
can
find
a
conformer's
testing
way
of
the
cassandra
community
to
do
like
how
to
do
conformance
testing
that
is
basically
from
the
outside
of
cassandra
operators,
but
jim
asks
if
we
like
the
community
should
evaluate
kudo.
So
I
volunteered
to
you
like
to
present
the
kudo
here
and
also
to
fill
in
the
gaps
that
would
be
seen
from
the
community
like
why
this
is
like.
B
You
know,
a
list
of
things
that
would
be
really
ideal
from
the
community
to
say,
like
we
are
not
going
to
use
kudo,
because
we
are
lacking
this
this
this
and
that
it
might
not
help
like
a
samurai
community,
but
you
have
to
be
like
you
know
like
keep
in
mind.
Maybe
if
we
develop
those
features
for
kudo,
maybe
next
community
like
say
apache
droop,
that
has
like
a
really
bad
operator
right
now
they
are
just
having
a
helm
chart.
B
They
want
to
build
an
operator
and
we
don't
have
like
kubernetes
expert
in
the
druid
community.
Might
they
might
use
these
features?
You
know
like
what
the
what
we
get
from
this
feedback
from
the
cassandra
community
and
they
might
go
ahead
and
like
build
an
operator
on
top
of
kudo
instead
of
like
learning
and
somebody
with
kubernetes
knowledge
land
in
the
druid
ecosystem
of
bi
and
like
everything
and
then
only
that
day,
we
will
have
some
serious
operator
that
will
be
out
there
and
like
available
for
to
the
community.
A
All
right
well,
this
has
really
been
interesting
boy.
I
feel
like
there's
a
lot
more
to
discuss
here.
Probably
I
I
want
to
go
look
at
more
of
the
kudo
project
and
I
think
everyone
else
will
too
very
interesting
food
for
thought.
Just
just
in
general,
operators
are
working.
A
I
I
I
will
admit
I
didn't
know
a
lot
about
this
project,
but
it
seems
like
this
is
a
this
is
a
bid
to
change
the
way
we
do,
operators
and
kubernetes
in
a
way,
that's
a
lot
more
intelligent,
or
at
least
reliable-
is
that
the
right
word,
yeah,
consistent,
approachable,
maybe
approachable,
right
sure.
Now,
whether
or
not
this
is
the
right
idea
or
insight
like
how
much
of
this,
if
it's
in
the
project,
I'm
not
really
sure
but
it'll
be
up
for
debate.
Okay,
any
other
questions.
Anyone.
B
Okay,
perfect
yeah,
so
I
will
just
go
and
do
it
like
smart,
small,
small,
smaller.
So
what
we
have
is
you
know
like
a
just
few
steps,
how
to
start
a
like
a
standard
like.
I
think
we
start
somebody
else
how
the
end
user
will
look
like.
So
this
is
like
from
zero.
Like
you
know,
all
these
stuff
that
are
included,
so
we
are
not
hiding
anything
here
how
it
would
look
like
right.
So
first
you
have
the
kudo
initialize
in
your
cluster,
so
that
is
like
with
the
kudo
in
it
that
can
be
possible.
B
B
So
this
is
crds
pack
just
taken
from
the
dollar
sex
operator
repository
like
github
repository,
so
I'm
just
going
to
like
install
it
as
it
is
coming.
There's
no
modification
done
from
like
you
know,
kuroshim
or
anything
like
that.
It's
just
taking
us
back
from
the
community
and
creating
the
crd
here
and
nobody's
watching
actually
this
year
right.
B
Html
objective
is
basically
the
definition
or
stacks
to
tell
the
shim
controller
that
we
need
a
generic
crd
controller
to
watch
a
certain
crd
right,
like
with
the
api
version
that
is
kasana.com
and
the
coin
is
customer
data
center.
So
the
time
that
I
create
this,
the
shim
instance
the
same
object.
What
I
see
here
is.
B
B
This
is,
you
know
like
for
the
end
user,
how
it
will
look
like
a
cassandra
data
center
object
and
with
one
size,
one
node
of
the
cassandra
cluster,
so
it
has
been
created
and
what
we
will
see
is
like.
Actually,
you
know
like
it
has
created
a
kuduro
cassandra
instance.
Let's
just
create
it
by
here.
The
best
way
to
see
that
would
be.
Let
me
just.
B
We
doing
what
is
going
on
behind
the
scene
like
a
lot
of
stuff
happened
here,
so
the
cassandra
center
actually
created
a
instance
of
the
instance
and
kudos
itself
is
like
taking
care
of
orchestrating
all
this
workload.
B
Service
accounts
table
set
like
roll
roll
binding
that
are
necessary
here
for
restructuring
budget
for
the,
and,
if
I
go
to
the
pods
here,
we
have
like
some
answers,
node,
that
is,
you
know
like
initializing,
and
it's
basically
one
node
cassandra
cluster
that
is
being
spin
up
by
using
the
customer
example
that
will
based
on
the
sexy
artist.
B
This
is
not
like
necessary
to
do,
but
if
we
this
three
with
all
the
goodies
that
the
kudo
is
providing
like
diagnostics,
bundles
or
like
plant
status
in
that
case,
so
we
can
see
like
what
is
going
on.
So
it's
trying
to
deploy
that
you
just
deploy
the
car
back
and
the
pre
node
is
complete.
And
now
it's
trying
to
buy
the
node
of
the
cassandra
like
cluster.
B
B
B
B
Yeah,
so
no
like
what
I
was
just
like
trying
to
do.
The
demo
like
just
show
like
just
if
I
don't
like,
where
you
guys
lost
me.
It
just
created
like
from
casanova
yamaha,
just
created
a
cassandra
cluster
right,
and
I
think
like
that,
is
like
all
like
small
demo,
that
I
would
like
to
show
like
how,
in
the
these
three
files,
you
know
like
the
crd
spec
that
is
coming
from
the
like,
created
by
telesex
and
kasana
shim,
that
is,
defining
the
behavior
bridge
and
kasana
yama.
B
G
B
I
mean
no
like
here
we
are
trying
to
bridge
between
an
existing
kudo
cassandra
operator
and
you
know
like
a
existing
spec,
so
it
feels
like
easier,
but
the
behind
the
scenes
is
because
basically
the
kudo
kasundra
has
been
implemented
right.
So
this
is
not
like
some
magic
is
happening.
I
think
the
better
example
in
this
case
would
be
okay.
G
B
G
B
B
B
If,
if,
if
you
think
this
is
like
really
a
really
good
feature,
then
I
think
like
we
will
take
notes,
and
if
that
is
you
know
like
going
to
drive
to
do
more
good
operator
is
like
support
for
ansible.
Then,
of
course
it
will
be
there
right
so
being
in
the
cnc
cnc
of
sandbox,
meaning
that
we
can
help
the
community
and
listen
to
community
and,
like
you
know,
go
towards
like
a
direction
which
will
help
more
and
more
people
to
write
easily
the
operators
right.
B
Okay,
so
like
here
is
an
example
like
just
in
case
here,
there's
no
magic
here.
It's
like
I
want
to
build
a
my
stateful
service.
You
know,
like
that's
some
kind
of
external
service
where
I
define
my
type.
You
know
like
my
ports
and
number,
so
this
is
like
some
crd,
I'm
defining
to
extend
this
service.
You
know
like
behavior
and
all
I
have
to
like
what
I
have
to
do.
B
B
Next,
it
will
set
up
the
name,
microsoft
and
the
name
says
default
right,
so
it
will
just
create
for
the
five
ports
of
that
and
each
service
external
service
of
type
load
balancer.
So
this
is
not
like
a
real
like
use
case
that
I
would
like
to
like
do
we
are
using
that,
but
this
is
just
an
example
of
from
scratch
from
zero
to
a
working
operator
on
a
generic
crd
or
dynamic
crd.
However,
we
want
to
call
it
without
using
any
kind
of
gopro.
We
can
actually
write
over.
A
All
right
just
keeping
track
of
the
time
here
I
you
know
we
have
a
few
minutes
left.
I
will
say
if
there's
any
more
burning
questions,
but
this
will
probably
be
a
great
discussion
to
have
on
slack
or
in
the
mailing
list
to
continue
this,
but
I
think
everyone
is
going
to
be
probably
going
to
check
out
the
site.
A
I
want
to
remind
everyone
that
john
sent
out
a
pretty
lengthy
email
last
night
and
had
some
questions
some
of
it
pertains
to
today.
If
you
can
take
a
look
at
that,
I
think
this
is
a
great
discussion
point.
There's
a
few
discussion
points.
He
asked
some
questions,
so
I
would
love
to
see
some
of
that
discussion
happen
there
in
the
mailing
list.
A
Let's
reply
make
sure
to
hit
reply
all,
but
let's,
let's
take
that
conversation
over
to
the
mailing
list,
I'll
put
a
meeting
on
the
calendar
for
next
week
at
this
time,
just
so
that
we
can
discuss
that
mail,
the
email
more,
but
I
would
like
to
see
that
we
could
discuss
it
while
before
then
on
the
mailing
list.
It's
a
lot
of
open
information.
A
Thank
you
zane
and
the
rest
of
andreas.
Thank
you
very
much
amethyst
for
coming
and
talking
to
us
about
this.
This
is
this
is
so
classified.
This
is
something
I
did
not
know
now.
I
know
things
and
I
I
really
do
need.
I
need
to
go
dig
into
this
more
myself.
Yeah
l
didn't
give
us
a
thumbs
up.
This
is
something
I
did
not
know.
H
Yeah
very
helpful
yeah
very
helpful.
Thank
you.
B
Thank
you,
patrick
for,
like
letting
me
have
some
last
minute
in
the
item,
so
it
was
really
really
and
I
think
like
we
like.
We
will
definitely
talk
on
slack
or
mailing
list
and
it
would
be
really
helpful.
You
know
like
to
all
the
good
bad
negative
positives.
You
know
like
feedback,
because
we
really
want
to
take
some
kind
of
feedback,
and
in
that
sense
it
will
be
like
helpful
to
shaping
the
future
features.
Often
like
operator
builder
toolkit,
like
kudo
yeah,
okay,.
G
But
I
didn't
want
to
give
negative
feedback
it's
just
difficult
to
to
give
feedback
on
the
after
five
day,
five
minutes
demo,
it's
complicated
when
you
spend
months
trying
to
to
find
the
right
code
to
to
it
seems
quite
magic
so
and
I
don't
believe
magic.
So
there
has
to
be
something
behind
anyway.
Okay,.
A
A
I
I'll
post
that
on
the
I'll
get
this
video
posted
and
we'll
get
this
out
there,
but
yeah
stay
tuned
for
next
week
and
go
look
at
the
mailing
list.
Dev
mailing
list
see
everyone.