►
Description
Being able to rapidly iterate on, build, and test your code is key to being a productive developer. Without local automation, working with the numerous platforms and technologies in your stack can become very frustrating.
In this webinar, Ben Bromhead CTO of Instaclustr will explore best practices to easily integrate Apache CassandraTM into your development workflow, so you spend more time writing good code and less time fighting your environment.
Attend to learn:
- How to setup a local Cassandra environment (single and multi-node)
- How to run multiple versions of Cassandra
- How to integrate Cassandra into your local build and test process
- The development tools best suited to work directly with Cassandra
A
You
know,
particularly
given
that
it's
a
database
that's
designed
to
be
distributed,
and
you
need
to
be
able
to
test
your
code
in
a
way
that
covers
different
use
cases
or
sorry
that
covers
different
scenarios
when
you're
connecting
to
a
cluster,
that's
more
than
just
you
know,
say
one
node.
So
what
we'll
do
is
in
this
webinar
will
cover
over.
It
will
cover
off
how
to
set
up
a
local
Cassandra
environment.
You
know
this
is
locally
on
your
laptop.
How
to
add
on
multiple
versions
of
cassandra.
A
Cassandra
is
a
very
fast-moving
project,
particularly
the
the
open
source
project.
You
tend
to
see
major
releases
every
six
months.
If
you
actually
look
at
the
developers,
live
they're,
actually
looking
at
moving
to
a
much
more
aggressive
release.
Time
frame
that
follows
a
bit
of
a
tick
tock
approach,
very
similar
to
the
way
that
Intel
releases
are
there
cpus?
So
would
you
know
with
the
idea
that
brings
a
little
bit
more
stability,
but
it
also
meant
that
new
features
get
integrated
into.
You
know
the
main
version
of
extender
a
little
bit
quicker
Plus.
A
On
top
of
that,
you
know
how
do
we
also
work
with
Cassandra
in
terms
of
creating
a
you
know:
a
reliable
test
environment?
How
do
we
integrate
it
into
unit
tests?
How
we,
you
know,
integrate
it
into
our
smoke
tests?
How
do
we,
you
know,
work
it
into
the
larger
kind
of
staging
environments
that
we
all
run
and
then,
last
but
not
least,
a
lot
cover
off
a
number
of
difficult.
A
A
So
you
know
the
challenge
of
making
all
this
work.
Is
you
know?
How
do
we
essentially
do
this?
How
do
we
work
with
it
on
a
daily
basis
as
developers
so
that
you
know
Cassandra's
not
getting
in
the
way,
and
it's
just
another
part
of
our
toolkit
that
we
used
to
build
all
the
maps
so
what
we
needed
to
do?
We
need
a
way
of
you
know,
working
with
or
working
with
this
hand,
in
a
way
that
you
know
it's
simple.
It's
fast,
you
know
the
workflow,
it's
somewhat
logical
and
not
too
onerous.
A
We
also
want
the
environment
to
kind
of
be
as
close
as
possible
to
production,
but
without
being
painful
to
use
and,
and
then
the
last
kind
of
challenge
is
actually
you
know
understanding
what's
going
on
under
the
hood
and
how
the
choices
we
make
in
you
know
when
we're
writing
code
when
we're
developing
how
that
kind
of
impacts
Cassandra
and
how
it
works
within
Cassandra
and,
of
course,
making
sure
that
you
know
the
things
don't
blow
up.
You
know
when
we
deploy
and
push
into
production.
A
So,
at
each
stage
of
the
developers,
work
for
you
kind
of
got,
you've
got
bearing
levels
of
interaction
right
and
what
and
what
I
mean
by
interaction
is
how
do
we
as
developers?
What's
our
workflow
like
so
you
know,
normally
what
we'll
do
when
we
put
your
on
the
day
today,
you
know
tasks
that
we
perform.
You
know
we're
going
to
be
writing
code,
we're
going
to
be
testing
it
and
you
know,
there's
also
a
fair
amount
of
research
that
goes
into
it.
So
let's
first
interests
the
idea
of
writing
code.
A
You
know
it's
kind
of
that
write
some
code
compiled
of
the
work.
Does
it
make
sense?
Is
it
done
in
the
best
way
that
we
can
do
it
and
then,
once
we
finish,
the
unit
work,
it
small
doesn't
work
with
everything
else
as
a
larger
system.
So
at
each
stage
of
these
tasks
that
we
do
during
our
days,
do
we
have
enough
information
to
make
to
make
what
we're
doing
work
if
it
actually
doesn't
so,
does
the
information
of
the
tests
that
we're
writing
you
know?
Is
it
helpful?
A
A
A
So
I've
just
downloaded
these
from
Cassandra
got
Apache
org.
There's
a
number
of
districts
out
there.
You
can
get
packages
for
you
want
to.
You
can
get
packages
for
red
tides.
You
can
just
get
the
plane
trouble.
The
trouble
will
work
on
any
Linux,
Mac,
OS
and
windows
machine
as
well
as
long
as
you've
got
a
fairly
recent
version
of
Java.
A
A
Depending
on
what
version
you
use
there's
a
number
of
different
things
that
you
have
to
do
in
order
to
get
it
working
locally.
First,
so
with
Canada
the
Cassandra
20
branch.
In
order
to
get
it
up
and
running
locally
on
your
machine,
you
will
need
to
have
a
look
at
the
cassandra
llamo
file.
If
there's
a
few
hard-coded
defaults
that
usually
won't
work
with.
A
You
know
running
it
from
you
know
a
local
machine
straight
out
of
the
box
and
the
main
one
is
the
directory
in
which
catan
will
store
the
data
files.
So,
if
you're
running
out
locally,
my
guess
is
that
you
actually
don't
want
to
sandra
writing
directly
to
your
violet
or
the
global
VAR
lib
directory
within
your
work,
your
workstation
simply
from
either
a
permissions
point
of
view,
but
sometimes
it's
also
a
good
idea
to
keep
all
those
of
the
files
that
Cassandra
will
create.
A
A
From
the
working
directory,
so
what
we're
going
to
do
is
we're
going
to
put
a
dot
slash
in
front
of
it,
so
I'm
going
to
jump
through
here
for
those
who
are
wondering
I'm
currently
using
them
and
just
searching
through
it.
Unfortunately
highlighting
is
not
of
syntax
highlighting
Fiamma
buzzers,
not
working
on
my
copy
of
them
today.
So
that's
pretty
cool,
so
the
main
place
we'll
need
to
do
it
that
three
places
in
the
am
or
file
it
is
the
data
directory
the
commitment
directory
and
the
case.
A
This
directory
will
need
to
update
those
once
you've
done.
That
you'll
probably
also
want
to
update
the
log
properties
file,
as
it
will
also
try
to
write
the
log
to
the
bars
for
this
last
fireplace
log
directory.
As
you
can
see
here,
I
have
already
modified
the
path,
so
it
should
just
do
it
from
the
working
directory
of
where
I
run
Cassandra
phone.
A
Who
alrighty
so,
let's
see
what
it
actually
looks
like
the
way
that
I
like
to
run
Cassandra
locally
from
a
tarball
installation
is
I
like
to
run
it
in
the
foreground.
This
means
that
logging
is
automatically
pushed
straight
to
the
console.
It's
done
via
that
log4j
properties
file
anyway,
but
the
main
benefit
is
I
can
see.
A
A
The
new
data
directory
is
created
from
you
token
for
itself,
and
you
created
all
the
relevant
key
spaces
in
the
system
directory
and
we
are
now
going
to
go
so
what
I'm
going
to
do
is
I'm
going
to
split
off
split
my
window
in
half
here
and
we
are
going
to
go
back
to
the
directory
that
we
were
working
in
20
to
16
from
here.
We
can
now
jump
straight
into
the
clutter,
so
we
can
have
a
look
at
what's
going
on.
Let's
go.
Have
a
look
at
a
system
table.
A
A
A
A
I
was
actually
going
to
show
you
guys
how
to
work
with
multiple
modes
teasing
just
an
extracted
tarball,
but
when
I
actually
ran
through
this
previously,
it
ended
up
taking
me
about
10
minutes
to
run
through
it,
because
for
each
node
that
you
want
to
run
you've
got
to
have
you
know,
you've
got
to
duplicate
amilcar
you're,
going
to
then
have
different
data
directories.
Commit
log
directories.
You're,
then
going
to
bind
it
to
different
interfaces.
That
you've
got
to
work
out,
how
to
do
that
and
it
becomes
a
lot
more
complicated.
A
Cpm
is
a
it's.
A
project
written
in
Python,
released
by
believers,
still
rang
one
of
the
the
core
committed
or
developers
to
the
Cassandra
project.
He
also
works
for
datastax.
That's
essentially
at
the
set
of
scripts
to
create
manage
you
know
and
destroy
local
Cassandra
classes.
It's
all
based
it
on
TCM
live,
which
is
a
Python
library
that
lets
you
programmatically,
create
and
manage
these
clusters.
A
A
A
A
A
Cool
all
right,
so
what
we'll
do
is
we'll
stop
our
currently
running
foreground
pro
version
of
Cassandra
and
let
us
have
a
look
at
CCM,
so
CCM
can
be
installed
by
either
downloading
the
repository,
so
you
know
get
clone
and
I
will
post
the
repository
link
I'm
very
shortly.
You
can
also
install
it
using
pip.
So
pip
is
a
Python
package
manager
that
is
based
upon
disk
tools.
If
we
hello
would
here
just
as
simple
of
doing
that,
of
course,
I
install
it
globally
to
my
packages.
A
So
it's
nice
and
fun
and
I've
already
got
it
installed
like.
If
you
didn't
it
would
you
know,
got
download
it
compile.
It
may
be
all
ready
to
run.
So,
let's
have
a
look
at
what
CCM
actually
does,
such
as
close
that
so
we've
got
a
bit
of
a
more
full
screen.
See
you
see
ya.
So,
let's
just
have
a
quick
list,
there's
an
awful
lot
of
options
that
are
present
but
the
main
ones
that
will
be
interested
in
creating
stop-start
and
list.
A
It
also
has
a
number
of
options
that
you
can
or
command
that
you
can
run
against
node,
but
we'll
get
into
that
once
we've
created
a
cluster,
so
let's
create
a
cluster
using
CCM,
so
the
commands
is
CPM
space
create.
You
can
then
also
specify
a
number
of
options,
so
what
I'll
actually
do
is
I'll
show
you
all
the
options
you
can
currently
use.
So
if
you
add
that
h
after
a
sub
command
with
CPM,
it
will
give
you
a
full
list
of
the
options.
A
As
you
can
see
here,
it's
very
configurable.
You
can
do
things
like
choosing
the
petitioner.
You
can
actually
tell
it
to.
Dfs
then
applies
instead
of
the
open
source
version
of
Cassandra.
You
can
do
things
like
specify
the
number
of
nodes
you
can
tell
it
to
start
it
automatically
to
an
able
binary
protocol
by
default.
If
you
using
an
older
version
of
Cassandra,
you
can
also
tell
it
to
enable
things
like
remote
debugging
for
the
JVM
is
your
kind
of
working
on
a
patch
to
Cassandra.
A
A
We
want
three
nodes
creators.
Duffy
lets
us
specify
the
version
of
Cassandra
in
this
case
I'm
asking
for
two
dot,
one
dot,
seven
and
the
name
of
the
cluster
is
going
to
be
called
webinar.
This
name
will
also
flow
through
to
the
clusters.
Name
is
specified
within
the
Cassandra
demo
farm.
So
let's
create
that
alright,
so
that
went
and
created
that
pretty
quickly.
In
the
background,
what
it's
actually
doing
is.
It
is
downloading
a
version
of
Cassandra
this.
It's
actually
downloading
a
tarball
that
contains
all
the
sources
and
it
will
compile
it.
A
What
I've
actually
done
is
in
the
back
there
is
before
this
is
I've
previously
run
a
version
of
Cassandra
2017
using
CCM.
So
it's
already
done
that
in
the
background.
But
if
I
was
to
do
it
with
a
earlier
version,
let's
say
we
wanted
to
kind
of
test
two
dot,
one
dot
to
maybe
we've
got
an
old
customer.
Want
to
test
you
know
some
folks
or
something
was
going
on
there
you'll
see
that
will
start
to
download
the
source
from
the
Apache
archive,
and
once
it's
done
that
it
will
start
to
compile
it.
A
So,
just
on
that
note,
I
won't
let
it
go
through
the
whole
way,
as
it's
a
little
bit
unnecessary,
I'm
sure
you've,
all
those
that
all
you
guys
and
be
able
to
seen
something
download
before
like
keep
in
mind
that,
in
order
for
you
to
write
to
work
with
CDM,
you
will
need
a
jdk
installed.
So
the
java
development
kit
and
you'll
also
need
maven
an
ant
installed
as
well.
So
there's
some
some
java
compiled
tools
enough,
because
CCM
will
build
sandra
in
the
background.
A
So
if
we
then
run
CCM
list,
what
that
will
show,
you
is
your
show
list
of
classes
that
were
previously
created
with
CCM
and
I'll
show.
What's
called
the
active
one,
so
we
can
see
here,
we've
got
webinar
and
then
we've
got
a
few.
Other
classes
have
been
listed
here,
so
this
is
really
cool.
What
it
actually
lets
you
do
that,
let
you
create
different
Kostas
with
different
number
of
sight.
A
So
if
we
have
a
look
at
my
I
of
config,
what
you'll
see
here
is
that
my
loopback
address
or
my
loopback
adapter-
has
a
number
of
different
aliases
down
to
it.
So
what
I've
done
is
I've
got
127
doctorate
of
0
1,
which
is
you
know,
that's
kind
of
always
there,
but
I've
been
created
two
and
three,
and
then
for
some
other
exercises
that
will
go
through
a
little
bit
later
on.
We've
got
dot
one
dot
to
all
the
way
through
down
through
to
top
sticks
with
them
with
mac
OS.
A
A
Identifier
then
alias
the
address
and
then
up
this
is
you
can
run
this
again
and
again,
even
if
you've
already
created
the
address
cuddle.
Alright.
So
let's
actually
start
this
closer.
So
it's
very
simple.
You
just
make
sure
you're
on
the
right
one.
You
then
go
CCM
start
now,
it'll
take
a
little
while
to
start
up,
you
might
be
a
few
errors
pop-up
right
there.
That's
because
I've
done
some
funky
stuff
with
my
java
class
path
with
some
different
versions,
but
that
doesn't
have
much
of
a
material
impact
on
this
demo.
A
So
we
go
CPM
status.
It
will
then
show
currently,
what's
going
on
so
we've
got
node
1
2,
&,
3
they're
all
listed
as
up.
If
we
then
have
a
look
at
what's
running
in
a
background,
we
can
see
that
there
are
three
Cassandra
processes
listed
here:
apologies
for
the
formatting,
that's
just
one
of
the
joys
of
when
you're
using
crap
cool.
So
what
can
we
do
with
TCM
to
these
actual
notes?
So
we
can
actually
then
start
to
Ron
command
against
it.
A
There
we
go
so
that
gives
us
a
view
that
we're
probably
a
little
bit
familiar
with,
and
it
shows
us
the
three
notes
that
were
working
with.
We
can
then
jump
into
cql
shell.
There
we
go
we're
ready
to
go.
We
can
also
even
do
things
like
apply
a
schema
to
it.
So
what
if
you
scheme
is
here,
let's
go
basic,
seek
you
out.
A
So,
as
you
can
see
here,
CCM
has
actually
made
what
we've
previously
done
with
the
the
tarball
install
a
lot
quicker
and
a
lot
simpler
to
manage
what
actually
happens
on
the
under
the
hood,
so
CPM
create
a
directory
in
your
in
your
own
dirt
called
CCM,
and
that
contains
all
the
directories
that
represent
your
current
club,
the
clusters
that
you've
created
the
file
current.
It's
just
a
point:
that's
just
a
text
document
with
the
name
of
the
currently
active
closer.
A
So
let's
jump
into
one
of
these
directories
and
actually
see
what's
going
on
under
the
hood.
So
here
we
have
three
separate
directories
to
the
three
nodes
that
were
created
and
we
have
a
configuration
file
here.
We
see
the
you
know
that
some
configuration
options
that
apply
to
the
cross
towers
are
also
like
number
of
tokens.
To
start.
You
know
native
transport,
the
install
directory,
the
number
of
rows,
which
knows
we're
going
to
use
the
speeds
so
on
and
so
forth.
A
This
cluster
configuration
gets
applied
to
the
node
as
a
whole,
so
let's
jump
into
node
one.
So
no
one
has
a
few
directories.
It
has
the
directories
such
as
commit
log
data
logs
and
save
cases.
As
you
remember
from
the
tarball
example,
we
had
to
manually
configure
these
and
kind
of
manage
them
ourselves.
Luckily,
CPM
jumped
up
for
us
as
well.
It
also
manages
the
process
or
writes
the
PID
file.
If
we
have
a
look
at
the
conf
directory
will
see,
it's
filled
with
the
normal
Cassandra
configuration
files.
A
These
are
generated
from
crossfit
com,
as
well
as
the
note
comfort
as
well.
So
if
we
have
a
look
at
that
before
I
jump
into
that
will
see
that
there's
then
some
no
specific
configuration
options.
So
here
it
sets
the
you
just
the
interfaces
that
applies
to
the
name,
whether
it's
going
to
be
remotely
debugs
song
so
forth.
So
that's
how
it
kind
of
manages
it
all
and
there's
a
couple
of
scripts,
sorry
that
this
Oct
em
it
is
the
scripts
that
kind
of
manage
that
all
for
us,
which
is
really
helpful.
A
You
know
the
different
versions
of
Cassandra
well
install
those
in
the
repository
folder,
so
here
we
see
the
different
versions
that
have
these
in
the
different
versions
that
I've
actually
used
in
the
part
of
it,
some
20
branches
and
she
got
one
branches.
If
we
jump
into
two
dot
one
dot,
seven,
we
will
see
that
it
looks
very
similar
to
what
you
would
get
from
downloading
the
source
code
and
building
it
yourself.
A
A
Yes,
you
can
define
the
directories
where
cassandra
stores
the
information
or
wet
BTM
stores.
It
I
believe
that
configuration
or
sorry
a
come
online
flag
that
you
can
pass.
We
can
tell
it
to
store
it
in
a
different
directory
if
you
don't
want
to
sitting
in
the
default,
which
is
your
home
directory.
Definitely.
A
So
one
of
the
one
of
the
projects
that
we
like
to
use,
it's
called
justamber
unit
and
what
it
does
is
200
unit
is
instead
of
I
guess
some
Java
passes
that
kind
of
wrap
around
an
embedded
version
of
Cassandra,
and
it
provides
some
kind
of
your
very
useful
helper
classes
that
let
you
load
schemas
into
Cassandra
lets.
You
run
it
within
your
test
harness
and
it
fits
very
nicely
into
the
j
unit
ecosystem,
the
other
benefit
of
it.
Is
it
it's
quite
portable,
so
I
maximum,
because
it's
all
run
within
your
test
harness.
A
So,
if
you're
using
j
unit,
you
don't
have
any
external
dependencies
on
that
makes
it
very
portable
and
very
easy
to
integrate
that
into
any
COI
souls
or
build
service
that
you
might
have.
So
what
I'll
do
is
we're
going
to
have
a
quick
demo
Cassandra
unit
and
then
I'll
get
into
some
other
test
classes.
That
will
be
helpful
and
more
useful
and
languages
other
than
Sandra
Arthur
other
than
Java.
So
let
me
just
bring
up
my
IntelliJ
window.
A
A
Alright,
so
what
you
can
see
here
is
so
I
run
IntelliJ.
The
project
that
I
have
up
here
is
a
project
called
Apache
Zeppelin
Apache
Zeppelin
is
a
like
a
web
notebook
and
query
application
for
a
patchy
spark,
and
what
I've
done
is
I've
actually
written
a
some
functionality
that
makes
it
very
easy
to
integrate
with
Cassandra
and
to
run
SQL
queries
against
Cassandra
I
then
went
to
United
submits
attached
to
the
upstream
project
and
then
allow
that
looks
all
great,
but
of
course
he
needs
and
test.
A
A
Now
I
go
too
much
into
detail
because
I
know
that
everyone,
not
everyone,
is
in
Java
developer
and
even
Java
developers.
You
don't
I
particularly
enjoy
staring
at
XML
all
day,
but
it's
very
simple.
We
declare
standard
unit
the
version
that
we
want.
What
scope
we
wanted
in
I
like
to
exclude
dependencies
that
are
being
used
elsewhere
in
the
project,
so
particularly
the
data
stack
core
driver
and
also,
if
you
exclude
Cassandra,
dot
or
and
then
define
it
outside
of
the
Cassandra
unit
dependency.
It
actually
lets
you
control,
which
version
of
Cassandra.
A
You
run
the
test
against,
because
the
Cassandra
unit
it
comes
with.
It
includes
a
version
of
Cassandra
with
each
one
of
us
releases,
but
as
a
dependency,
but
that
might
not
necessarily
be
the
one
that
that
you're
using.
So
if
we
jump
back
to
our
test
class
here,
what
you'll
notice
is
I've
defined
a
a
Sandra's
dql
unit.
A
In
the
background-
and
you
can
see
in
these
comments
here-
it's
essentially
doing
a
embedded,
Cassandra
server
help
off
and
it's
starting
an
improved
in
embedded
version
of
Cassandra
I
can
actually
have
these
calls
in
might
a
top
class
and
I
could
manually
load
it
myself,
but
you
know
I
just
kind
of
wanted
to
do
it
all
automatically
for
me.
So
let's
actually
see
what
happens
here.
I
am
going
to
just
change
the
logging
level
here,
so
we
can
actually
see
Cassandra,
starting
in
the
background,
and
I
am
going
to
run
these
tests.
A
A
A
A
A
Hit
the
Go
button
I
should
be
able
to
see
here
is
the
stock
output
look,
and
you
can
see
here
that
it's
actually
clearing
stander
the
test
is
passed
its
queried
on
the
spot
test.
Each
space,
which
was
defined
in
this
standard
cql
while
he
took,
creates
a
table
called
test
as
insert
some
kind
of
dummy
data,
and
here
we've
got
our
third
statements.
We
make
sure
that
the
result
is
actually
true
and
then
it
equals
a
couple
of
things.
A
A
You
I
will
jump
through
this.
So
yes,
so
what
I
was
actually
looking
to
talk
about
before
my
slider
call
their
jumbled
out
of
water?
There
is,
you
know,
obviously
you
can
also
use
your
various
testing
frameworks
against
manually
deployed
version
of
Cassandra,
so
either
you
know
using
the
tarball
install,
but
that
will
require
to
do
things
like
calling.
You
know
trunk
a
drop,
key
spaces
and
then
separately
set
up
Cassandra.
You
know
using
your
CIO
and
integration
tools
with,
however,
your
test
framework
does
it
and
that
can
be
a
little
bit
painful.
A
What
we
really
want
is
you
know,
extender
units
all
all
well
and
good,
but
it's
very
specific
to
Java.
It
also,
you
know,
doesn't
allow
you
to
do
things
like
testing,
whether
you
know
your
application
works
when
you're
using
different
consistency
levels,
how
it
reacts
when
you've
got
one
no
down
how
it
works.
Is
you
know
if
you
entered
multi
data
center
environment?
You
know
all
that
kind
of
thing.
So
it's
a
very
like
it's
a
very
easy
and
flexible
framework
to
you
and
I'm.
A
A
So
when
it
comes
to
testing
and
automating,
our
test
would
actually
really
like
to
use
see
them,
because
it
does
a
lot
of
the
work
of
setting
up
complicated
or
what
I'd
call
more
realistic
to
standards,
apologies
and
then
being
able
to
use
that
for
our
tests.
On
top
of
that,
we
also
want
some
way
of
using
it
in
a
way
that
I,
guess,
flexible
or
portable
between
different
languages,
so
Oct
M
is
also
used
for
Sanders
distributed
test.
It's
also
actually
used
within
two
testing.
A
A
A
A
What
this
is
is
its
test
to
see
how
the
driver
handles
various
levels
of
consistency.
We've
also
got
smothered
at
here.
We've
got
an
authentication
tests
and
a
stress
test.
So
what
we'll
do
is
we'll.
First,
have
a
look
at
the
authentication
tests
as
this
one's
a
little
bit
quicker
and
I
am
aware
that
we
are
running
out
of
a
little
bit
of
time
and
I
want
to
leave
some
time
for
questions.
So
as
we
see
you,
what
the
test
is
doing
is
it's.
A
Creating
this
class
called
CPM
bridge
CVM
bridge
is
the
class
within
the
driver
that
they
used
to
interact
with
ctm
the
piping
project.
You
can
see
some
things
here:
its
environment
prop
arm
properties
before
a
culvert
and
sculpting
some
codes,
kind
of
management
executing
the
process,
all
that
kind
of
stuff.
So
let's
give
it
a
quick,
go
close
button,
wait
for
it
to
cool
all
right,
so
here's
going
to
call
CCM
bridge
create.
So
this
is
very
similar
to
what
we
were
doing
on
the
command
line.
Calling
ctm
space
create.
A
You
know
we're
defining
it,
see
him
create
by
the
bridge.
It
has
a
number
of
default
operations
or
if
you
actually
have
a
look
below
what
a
little
do
is
it'll
it'll
make
some
subsequent
calls
to
CCM
to
once
it's
created
that
cluster
it
can.
Actually,
you
can
actually
tell
it
to
add
nodes
by
calling
like
populate.
You
can
tell
it
to
update
its
configuration
to
start
it.
You
know
so
on
and
so
forth.
A
And,
what's
it
go
very
good?
So,
as
you
can
see,
all
these
tests
are
fairly
short.
You
can
see
in
my
output
window,
you
can
see
some
of
the
output
from
the
Cassandra
driver
is
detected,
a
new
host
Cassandra
host
1270
dot,
one
dot
one,
and
so
that's
the
nodes
that
CCM
created
and
it
managed
to
connect
properly
during
these
tests.
A
If
you
actually
have
lets
you
know,
if
we
actually
have
a
look
at
DCM
on
our
command
line,
it
won't
actually
show
up,
because
what
the
the
test
class
and
the
bridge
park
has
done
is
actually
created.
The
CCM
cluster
in
a
different
directory
and
as
one
of
the
other
questions
was,
you
know,
can
we
change
the
location
of
the
data
directory
in
the
commit
log?
You
can
also
change
the
entire
location
of
CPM
itself.
A
A
I'm
going
to
keep
okay
cool
yeah,
so
if
you,
if
you're
working
with
with
Java
okay
I,
will
I'll
backtrack
15
seconds
so
yeah.
So
how
do
we
integrate
with
Cassandra
not
set
two
frameworks?
Honestly
I
would
say
that
DCM
and
cisgender
unit
are
the
bestestest
Cassandra
unit,
while
it
does
require
no
additional
config,
Java
thirst,
and
so
you
know
it's
only
kind
of
useful
for
for
java,
I'm
not
one
hundred
percent
certain.
A
Whether
there
are
other
frameworks
out
there
that
a
very
similar
success
sandra
unit
so
to
let
Ruby
or
Python
all
those
kind
of
languages,
but
CCM
kind
of
like
Phil's
bills
that
void
it
does
require
like
them
to
be
installing
the
CCM
to
be
installed
black
most
you
know,
kind
of
continuous
integration
or
testing
frameworks
do
provide
mechanisms,
for
you
know
ensuring
dependencies
are
kind
of
met.
Then
you
can
use
whatever
language
you're
using
you
can
use
the
CCM
bridge.
A
A
A
I
do
have
a
demo
for
that
I.
Will
that's
not
supposed
to
be
extending
its
supposed
to
be
dead,
stand
up,
I'll
actually
skip
that
one.
What
I
really
want
to
show?
You
is
actually
the
the
two
main
tools
that
I
tend
to
use:
a
lot,
which
is
c2l
shell
and
the
Cassandra
stay
at
life.
Now.
The
reason
why
I
quite
like
to
use
Cassandra
CLI
as
well
as
teach
yourself
is,
it
provides
a
lot
of
insight
to
what
Cassandra
is
actually
doing
under
the
hood.
A
A
A
Alrighty,
so
what
we've
done
is
we
have
imported
some
data
into
Sandra
I'll
quickly,
show
you
what
the
schema
looks
like
so
we
have
here
a
table
called
food
bar
has
named
text
ID
and
value
now,
one
of
the
things
that
a
lot
of
people
struggle
with
Sandra
when
they
first
get
into
it
is
the
data
model.
So
what
I
find
it
is?
A
It's
actually
usually
very
helpful
for
me
in
order
to
develop
it
I
guess
a
conceptual
idea
of
what's
going
on
under
the
hood
is
actually
to
get
in
and
play
with
the
data
of
myself
and
actually
have
a
look
at
what
it
looks
like
kind
of
under
the
hood.
So
what
we've
done
is
we've
created
a
table
called
food
or
bar
and
another
table
on
top
of
that,
as
well
and
in
c
ql.
What
we
can
see
is.
A
A
So
now
things
actually
look
a
little
bit
different,
so
we've
got
two
rules
here,
one
called
day
and
one
called
then
this
is
actually
quite
different
to
what
cql
shell
is
showing
us
as
far
as
it
has
15
rows,
with
the
names
Dave
and
then,
but
within
the
CLI.
It
actually
shows
very
clearly
Cassandra's
wide
column
format.
It
shows
name
as
the
the
column
name
and
then
the
value
here.
What
I've
done
is
I've
created
this
with
compact
storage,
so
it
shows
it
a
little
bit
more
succinctly.
A
I
won't
get
into
too
much
between
the
differences,
contact,
storage
versus
other
table
definitions,
but
what
you
can
see
here
is
that
by
using
TTL
shell,
when
you're
developing
your
schema
and
then
using
Cassandra
dash
their
lives,
you
can
actually
see
the
difference
between
what
you're,
creating
from
a
conceptual
or
a
logical
point
of
view
and
how
to
Sandra,
actually
writes
it
to
disk
in
that
white
column
format.
So
when
you're
kind
of
reasoning
and
thinking
about
your
data
model,
you
can
actually
see
how
your
partition
key
in
your
classroom.
A
Yes,
so
CLI
is
being
removed
in
22
I,
don't
know
what
a
better
option
is.
It
is
being
deprecated
I,
believe
it's
a
little
bit
so
the
decisions
deprecated
Cassandra
dash
CLI
was
made
with
the
refactor
of
the
underlying
storage
engine,
but
that
thing
puts
back
two
three
dot
0,
so
I'm,
not
too
sure
whether
they
are
actually
going
to
take
out
Sandra
dustier
live
in
two
da
to
given
that
they've
had
to
push
back
the
storage
engine
changes
in
three
dot.