►
Description
Don’t miss out! Join us at our upcoming hybrid event: KubeCon + CloudNativeCon North America 2022 from October 24-28 in Detroit (and online!). 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.
Scaling Databases with Vitess - Harshit Gangal & Manan Gupta, Planetscale
Vitess is a cloud-native storage solution that provides horizontal scaling of MySQL. In this session we will cover the high level architecture and the feature set offered including the ease of database management. We will showcase its compatibility with the popular web framework Rails and will demo how to bring up Vitess with Rails using the Kubernetes operator. Realizing the need to scale out already running applications, we will also demonstrate how to scale out an existing database running on AWS RDS/Aurora using Vitess.
A
Well,
I'm
hershey,
I
work
with
planet
scale
and
I've
been
maintainer
of
witness,
and
I
have
been
with
the
project
for
almost
six
years
now
and
with
me.
I
have
manan
who
is
also
working
with
planet
scale.
He
joined
as
an
intern
and
now
he's
also
a
maintainer
of
veterans.
He's
been
working
for
more
than
one
year
now,
and
we
are
talking
about
scaling
databases
with
witness
today.
A
So
let's
go
over
agenda,
we'll
be
talking
about
what
witness
is
where
it
got
evolved
and
how
it
how
it
looks
like
what
it's
it's
trying
to
solve
the
purpose
and
about
that
will
go
into
the
demo.
We'll
show
you
how
you
can
actually
import
data
from
aws
rds
to
witness
and
how
it
seamlessly
work
with
rails
or
wittes,
and
also
based
on
the
time
we'll
also
talk
about
some
upcoming
feature.
A
So
witus
is
basically
a
horizontal
starting
solution
on
top
of
mysql,
which
which
basically
means
that,
if
you,
if
you're
running
out
of
scale
on
my
sequel,
you
can
put
witness
on
top
and
it
will,
it
will
do
seamless
shorting
for
you
I'll
talk
in
more
details
about
it.
But
that's
what
with
us
is
at
a
higher
level.
It's
a
eighth
cncf
graduated
project
and
it
was
started
in
youtube
at
2010
and
it
was
then
donated
to
cncf
for
maintenance
and
it's
open
source
project.
A
A
A
Similarly,
for
your
data,
you
are
running
into
terabytes
or
petabytes
of
data,
and
you
cannot
basically
keep
it
in
single
minus
sql
instance.
Then
again
you
have
to
do
sharding
so
so
that
you
are
able
to
scale
and
also
your
and
also
connection.
So
you
have
a
lot
of
applications.
We
are
trying
to
just
connect
to
a
single
mysql
instance
and
you're
running
out
of
connections,
so
we
so
we
just
basically
do
connection
pooling
for
you
so
that
you,
you
can
scale.
A
Let's
go
into
some
features
now
because
I
talked
about
sharding,
which
means
you'll
have
a
lot
of
lot
of
my
sequences
running
per
shot
and
you
it
will
be
very
difficult
to
manage.
So
it
does
easy
cluster
management
for
you,
which
means
if
your
primary
goes
down.
It
knows
which
replica
to
bring
up
as
a
primary,
and
it
will
fix
all
your
application
stuff
and
you
you
just
keep
start
you'll
just
keep
serving
your
traffic
if
yeah
and
and
it
also
like
so
in
cluster
management.
A
Another
one
is
the
backup
recovery,
which
means,
if
you
can
tell
where
you
have
want
to
take
backup
for
and
it
will
it
will,
it
will
take
backup
for
you
and
whenever
you
start
a
new
replica,
it
knows
where,
which
is
the
latest
backup.
It
will
pull
it
down
and
it
will
again
plug
it
back
to
the
replic
primary
and
fix
your
application
for
you,
and
once
it
is
caught
up,
it
will
again
go
into
the
serving
state
for
you
and
that
will
also
just
start
serving
traffic
for
you
yeah.
A
Another
is
a
query:
consolidation,
which
means
if
you
are
hitting
same
kind
of
queries
or
same
query,
basically,
like
suppose
it
just
got
exploded
with
the
it
just
went
global
with
same
same
kind
of
information,
which
means
you'll
use
every
your
data
will
start
receiving
same
kind
of
query
to
your
same
chart.
Then
it
does
query
consultation
for
you,
which
means
it's
try
to
do
hot
pro
protection
for
you
and
it
will
consolidate
it,
which
means
it
will
not
send
all
the
same
kind
of
queries
down
it.
A
Another
is
the
human
errors
where
you
just
wrote
some
bad
query
or
you
try
to
select
all
the
data
from
all
the
shards
or
you
try
to
update
all
the
rows
and
stuff,
so
it
put
those
limitations
around
it,
so
that
you'll
you,
you
won't
run
into
getting
your
database
down
in
those
terms,
and
also
you
can
do
block
listing
you
can
do.
You
can
give
query
patterns
that
that
should
not
allow
you
and
it
will
handle
it,
will
ensure
that
those
kind
of
query
patterns
does
not
go
to
your
mysql.
A
So
before
I
go
into
the
architecture,
I
just
there
just
two
words
I
want
to
just
get
into
it.
One
is
shot.
I
already
talked
about
you.
Basically,
a
shard
is
nothing
but
having
a
primary
and
lot
of
replicas
running
and
then
you'll
have
multiple
shards
running
and
the
key
key
space
is
just
cinnamon
synonym
to
like
your
database,
which
means
a
key
space
is
basically
containing
of
multiple
charts,
so
in
our
demo
also
we'll
be
using
key
space
terms.
So
basically
it's
a
collection
of
shards.
A
Yeah,
let's
go
into
the
architecture,
if
you,
if
you
see
here,
we
have
something
called
shard
watch
or
two
shot
three
two
shot
in
which
belongs
to
one
key
space.
Here
we
are
running
mysql
and
on
top
of
it
we
have.
We
call
it
something
called
witty
tablet,
which
is
a
sidecar
which
is
sidecar,
which
is
running
along
with
your
mysql.
A
What
it
does
is,
basically,
this
is
the
one
which
manages
your
mysql
and
also
any
query
that
will
come
will
ultimately
come
to
this,
and
then
it
will
be
sent
down
to
mysql.
This
is
the
one
which
also
does
the
connection
pooling
which,
which
means
no
all
the
connections
will
be
handled
by
this
sidecar.
A
This
exposes
a
grpc
api
to
the
outside
world,
and
the
outside
world
is
basically
nothing
but
vt
gates.
Vt
gates
are
the
one
which
will
be
talking
to
the
video
tablet
using
the
grpc,
and
this
is
this-
is
the
entry
point
for
your
applications,
so
what
vtgate
does
is?
Basically,
it
will
receive
all
the
traffic
to
to
it
and
it
will
basically
vtgate
will
do
the
query
parsing
for
you
and
then
it
will
do
the
query
planning
and
then
it
will
execute
those
plans
and
vtgate
knows
where
your
data
resides.
So
it
will.
A
A
You
can
put
a
load
balancer,
basically,
so
that
you
know
how
to
make
the
discovery
and
how
to
connect
to
the
the
vtgate,
which
is
the
least
used
and
vtgate
talks,
a
mysql
protocol,
which
means
that
you
don't
have
to
change
anything
on
your
application,
and
it
knows
how
to.
Basically,
you
can
just
use
this
normal
mysql
driver
that
is
available
for
for
that
language,
and
it
will
just
continue
to
work,
as
is
so.
You
just
have
to
change
that.
A
Instead
of
directly
going
to
mysql,
you
can
just
you
have
to
go
through
the
vt
gates.
There
is
another
component
called
vtc
tld,
which
is
the
admin
part
of
the
width
cluster,
which
will
which
will
ensure,
which
will
help
you
to
manage
your
latest
cluster
itself
and
also
we
have
something
topo
server,
so
you
can
plug
in
any
turbo
servers
for
storing
with
test
metadata
into
it.
D
Hello,
can
you
guys
hear
me,
I
think
it's
working
fine
right,
okay,
I'm
alan
hello,
everyone
and
I'm
going
to
be
taking
you
through
the
demo.
The
demo
is
really
simple
to
follow,
but
it
is
extremely
powerful
in
what
it
does
so
we're
going
to
start
with
the
rails,
app,
which
is
connected
to
an
rds
instance,
and
the
entire
point
of
the
demo
is
to
move
from
that
rds
instance
to
with
tests
without
having
and
moving
all
your
data
from
rds
into
a
test.
D
So
first,
the
step
that
we'll
do
is
we'll.
First
have
a
test
cluster,
which
is
called
rds
on
top
of
rds
itself.
Rds,
mysql
and
rails
will
be
querying
with
srds
going
through
rds.
The
data
will
be
stored
in
rds,
but
will
be
routed
through
a
test,
so
we'll
be
using
the
vtgate
endpoint
and
a
vt
tablet
on
top
of
an
rds
external
data
store.
D
It
has
your
data,
but
the
data
has
also
been
copied
over
to
it
s
after
that,
once
everything
is
done,
everything
is
working.
We
can
remove
the
rds
instance
you
can,
you
can
choose
to
destroy
the
data,
keep
the
data,
do
whatever
you
want
with
it,
but
at
that
point
your
rails
app
is
running
entirely
with
your
test.
So
this
is
the
workflow
that
we're
going
to
follow
for
the
demo.
D
Let's
get
started
all
right
so
over
here
I
have
a
rds
instance
already
running
it
takes
a
little
while
to
spin
it
up
so
I'll
just
point
it
up
beforehand,
and
if
you
take
a
look
at
the
databases
that
we
have,
we
have
one
called
rails
app.
This
is
the
one
that
we're
going
to
use
just
before.
I
continue.
This
font
size
is
fine
for
everyone,
people
at
the
back.
Can
you
see
that
all
right
great?
So
if
you
use.
D
There
we
go
so
here:
I've
already
set
up
rails
as
an
app
itself,
so
you
see
that
there
are
two
internal
tables
that
rails
uses
the
ar
internal
metadata
and
the
schema
migrations.
Both
of
them
are
rails,
internal
tables
and
there's
one
extra
table
that
we
have
created.
It's
called
users
we're
only
using
that
table
for
the
purpose
of
this
demo,
essentially
we're
going
to
insert
data
into
that
users
table
and
we're
going
to
record
the
latency
as
to
how
fast
or
how
slow
it
was.
D
D
Okay,
so
we
go
over
here,
restart
this
page.
There
we
go.
I
already
had
inserted
a
few
amount
of
data
in
the
beginning,
but
now
it's
going
to
insert
about
four
users
every
second
and
it's
gonna,
keep
track
of
the
latency
that
it
took
to
do
those
insertions
averaged
over
five
seconds
and
that's
what
we're
plotting
over
here.
We're
also
keeping
track
of
the
total
error,
count
that
we
see,
while
we're
doing
those
insertions
right
now
we're
starting
with
zero
errors,
but
we'll
see
how
how
we
go.
D
There
we
go
so
here
we're
just
counting
like
we're
keeping
a
watch
on
the
number
of
users
that
are
there.
It's
essentially
a
very
easy
watch,
we're
just
doing
a
select
construct
from
users,
and
this
is
running
against
rds,
so
you
can
see
that
the
user
count
is
increasing
on
rds
we're
running
against
that
now,
if
you
remember
from
a
slide,
the
second
thing
that
we
want
to
do
is
spawn
off
a
bit
test
server
and
have
it
in
front
of
rds.
D
So
I
already
have
a
wet
test
running
as
well.
I'm
running
it
in
kind,
so
I'm
not
running
it
on
on
on
kubernetes
on
I'm
running
at
kubernetes,
but
not
in
gcp
or
aws.
You
can
do
that
too.
With
test
operator
works
with
all
of
those
platforms
right
now,
I'm
running
in
kind
locally,
and
I
already
have
it
set
up,
so
I
can
really
quickly
go
over
and
show
you
the
configuration
that
I'm
using.
D
D
You'll
also
have
a
mysql
instance
running
inside
and
over
here
we
have
an
rdst
space
and
if
you
see
it's
using
an
external
data
store,
so
it's
not
using
mysql
directly,
it's
using
an
external
data
store
and
here
you're
providing
the
parameters
to
how
to
connect
to
that
external
data
store
which
rds
user
idsdb
name.
These
are
all
environment
variables
that
I've
set
it
out
in
in
the
startup
script,.
D
D
So
we
go
over
into
the
database.
Configuration
university,
hamlet,
they're
here
right
now,
we're
using
those
environment
variables
that
are
configured
in
with
tests
as
well
rds
host
rds
db
name.
So
we
can
change.
These
host
is
localhost
because
I'm
running
it
locally
database,
we're
going
to
use
is
called
rds
because
that's
the
name
of
the
key
space
and
like
hershey,
said
the
key
space
is
like
an
equivalent
for
database.
In
the
test
analogy,
the
user
we're
going
to
use
is
user.
D
D
D
This
is
the
witty
gate
page.
This
is
like
a
wit
test
bt.
Do
you
guys
remember
that
the
proxy
layer
that's
on
top,
which
is
connected
with
the
users
connect
to,
and
this
is
the
plane
for
that-
a
ui,
and
it
shows
the
purpose
that
serving
so
early
on
it
was
no
qps,
because
we
weren't
wearing
bits
directly
at
all,
but
now
we're
going
through
the
test
even
to
rds.
So
we
have
this
graph.
That's
coming
up
for
qps
at
bt
gate.
D
Okay,
so
this
is
all
working
fine,
we're
now
running
we're
still
going
to
rds.
So
look
at
the
latency
latency
has
come
down.
It's
stabilized
to
the
point
that
it
was
before
it
spiked
up
for
a
bit,
but
it's
back
down
to
where
it
used
to
be.
It's
still
going
to
idea,
so
the
data
is
stored
in
rds.
If
you
go
over
to
the
watch
on
rds,
you
see
that
the
data
is
still
being
stored
in
rds,
but
it's
going
through
a
test.
D
D
To
do
that
we
have
a
command
called
move
tables.
Now
I've
already
spawned
this
command
off
as
well.
Before
I
started
the
demo
move
tables
come
on,
it
takes
in
two
arguments.
You
can
give
the
source
key
space
which
for
us
is
rds
and
you
can
give
it
the
in
the
in
the
parameter
of
this.
You
give
it
the
destination
key
space,
but
that
is
rails
and
rails.
App
is
just
the
name
for
the
workflow
you
can.
D
D
There
we
go
so
the
copy
is
complete,
but
we
still
have
a
replica.
We
still
have
a
v
stream
running.
What
that
v
stream
is
doing
is
because
you're
inserting
data
consistently
constantly
into
rds.
You
want
to
keep
keep
copying
it
into
a
test
as
well
right
because
you
don't
want
to
lose
data
when
you
cut
over
from
rds
to
a
test.
D
D
Okay,
okay,
all
right,
so
that
one
second
time
lag.
That's
that's
generally
the
amount
of
time
it
takes
for
it
to
catch
up,
because
it
will
stop
right
from
the
rds
and
it'll
it'll
it'll
buffer,
those
lights
and
it'll
start
doing
them.
On
the
rdsp
space.
You
look
at
the
initial
start
state
that
we
had
that
we
had
not
switched
the
reads
or
the
rights
both
of
them
were
going
to
the
rds
key
space.
D
In
the
end,
our
current
state
is
that
all
the
reads
and
the
rights
have
been
switched,
you
can
choose
to
do
this
in
two
parts.
Just
switch
the
reads
first
and
then
switch
the
rights
or
just
do
the
switch
the
rights
first,
in
which
case
half
the
traffic,
would
be
going
to
the
test
key
space.
Half
the
traffic
would
be
going
to
the
rdsp
space
in
this
demo.
I've
done
both
together,
so
reads
and
writes
about
switched
and
we
go
over.
D
You
see
that
the
latency
has
dropped.
That
latency
drop
is
because
I'm
using
bittes
locally.
So
all
the
loopback
interface
calls
that
were
going
to
rds
server
spawned
off
in
paris
are
now
just
running
locally,
so
this
drop
is
coming
because
I'm
running
with
us
locally
and
you
see
the
error
count.
We
have
a
few
errors
that
happen,
but
I'll
come
to
that
point
later.
D
D
So
if
you
took
a
look
over
here,
it
says
that
any
query
that
comes
to
the
rds
users
table
should
actually
be
served
on
the
webtest
users
table
because
you've
done
the
switch
traffic.
So
essentially
your
app
does
not
need
to
change.
When
you
do
the
switch
traffic
once
you've
done
with
it
and
you're
happy
with
everything,
then
you
can
change
your
app
to
actually
start
serving
traffic
from
from
the
directly
from
the
test
key
space,
so
there
we
go.
All
we
need
to
do
is
change
this
to
the
test
and
like
before.
D
At
this
point,
we're
querying
directly
to
test
so
we're
at
the
last
step
of
the
demo
that
you
have
rds
running,
you
have
rails
running
and
it's
squaring
directly
to
the
test.
The
rds
is
not
being
used
and
if
you
take
a
look
at
the
watch
over
here,
this
watch
is
still
getting
data.
The
reason
that
is
what
the
reason
we
do.
This
is
until
you
actually
complete
the
the
entire
move
tables
command.
D
We
insert
the
data
back
from
the
test
into
rds
so
that,
if,
if
whatever
something
something
does
not
work
out,
there
are
some
queries.
Some
queries
are
not
working
against
the
test
because
the
shared
database-
we
have
my
sql
compatibility,
but
there
are
some
queries
that
won't
work.
If
something
like
that
you
hit
roadblocks
in
that
sense,
then
you
can
actually
go
back
and
you
won't
reduce
any
data.
D
This
takes
in
one
more
parameter,
it
says,
keep
data,
so
I'm
choosing
to
keep
the
data
in
the
rds
server.
If
you
don't,
if
you
don't
provide
this
parameter
it'll
by
default,
go
ahead
and
delete
all
the
data
that
you
had
in
the
source
key
space
and
if
I
go
ahead
and
look
at
rds
now,
this
count
is
now
stagnated
like
it's
not
going
to
increase
any
further.
It's
stabilized
because
we've
completed
the
workflow,
everything
is
moved
over
to
test.
D
D
D
So
actually
I
created
the
slide,
but
I
wasn't
sure
how
much
time
I'd
have
so
I
thought
that
I'll
talk
about
them
and
as
much
time
as
this
left.
So
we
have
enough
time.
So
this
first
one
is
vtr.
This
is
bts
orchestrator,
it's
a
fork
of
orchestrator
that
we
have
tailor-made
for
the
test.
Essentially,
this
is
the
so
hershey
talked
about
automatic
fixes
and
things
right
like.
If,
if
you
were
running
bts
and
kubernetes,
you
could
have
a
mysql
port
that
got
evicted
so
it
got
restarted.
D
If
it
restarts,
then
it's
its
replication
will
not
set
up
correctly
things
like
these,
so
right
now,
if
you,
if
you
so
right
now,
if
you're
not
using
vitesse
and
if
you're
doing
managing
things
yourself,
someone
has
to
go
over
there
and
fix
those
replications
right
and
vtr
is
the
automated
component
of
a
test
which
will
do
this
automatically.
It
will
go
over
it
to
check
that
there
are
automatic
failure
scenarios.
It
will
check
that
you
have
a
primary.
You
have
a
replica.
D
The
replica
is
not
connected
to
that
primary
or
that
it's
not
sending
some
icing
acts
or
it
is
said
to
read
only
so.
There
are
a
bunch
of
failure
scenarios
whatever
goes
wrong.
Vtr
is
the
single
single
thing
that
can
fix
it.
So
we
have.
We
have
operations
that
you
can
do
manually
as
well
through
the
btc
tld,
but
vtr
is
the
automated
failure,
fixing
thing
that
with
tess
offers.
So
if
you
have
youtube
running
anything
that
fails,
video
can
go
and
fix
it.
It
can
do
emergency
dependent
charts.
D
It
can
do
anything
like
if
the
primary
for
the
primary
fails.
We
can
even
switch
traffic
to
a
a
read-only
and
a
replica
server
and
and
guarantee
that
there
won't
be
any
data
losses,
so
we'll
find
the
one
which
is
the
most
advanced
and
if
you're
using
semi-sync,
the
one
which
is
the
most
advanced,
there
will
be
at
least
one
server
which
has
all
the
app
transactions
right
so
we'll
promote
that,
and
that
is
how
we
guarantee
that
you
won't
lose
any
data.
Even
if
your
primary
fails
and
these
things
happen
in
production
right.
D
D
Right,
so
this
is
the
ui
that
you
have.
This
is
the
vtc
tld
ui.
It
shows
the
shards.
It
shows
the
the
number
of
charge
that
you
have
in
each
key
space
right
now
we're
running
them
in
uncharted,
so
we
only
have
one
chart,
but
you
can
chart
them
out
as
your
data
grows
into
multiple
charts
and
if
you
go
over
in
here,
you
get
the
serving
charts
and
the
list
of
tablets
that
we're
running
so
currently
we're
running
in
one
one
primary
one
replica
mode.
D
This
is
the
old
old
ui,
so
it
does
the
work,
but
I
can't
actually
show
you
bt
admin
right
now,
don't
have
it
running
locally,
but
if
you
go
over
to
the
bittest
docs
and
you
spawn
it
off
yourself,
you'll
see
that
it's
a
much
better
ui.
You
can
look
at
how
queries
are
run
against.
You
can
look
at
the
look
and
look
look
at
the
instructions
that,
with
test
will
run
to
actually
execute
the
query.
It's
good
for
debugging.
D
You
can
do
all
the
operations
there
as
well,
so
you
don't
need
to
actually
go
to
the
to
the
cli
and
run
start
replication
or
something
like
that.
You
can
actually
do
it
through
the
bt
admin
as
well.
So
vt
admin
is
going
general
availability
in
the
next
release
of
a
test
and
vtr
is
going
general
availability
in
the
release
after
that.
So
these
are
the
two
great
amazing
features
that
are
coming
up
in
vertex.
A
Yeah,
just
to
add
to
that
vtr
is
already
used
in
production,
but
the
company
does
not
want
to
be
named
so,
but
they
are
already
using
in
production,
but
we
call
it
experimental
because
we
want
to
make
sure
that
we
are
ready,
like
as
a
witness
community
is
ready
to
take
on
videos,
but
it's
there.
People
are
already
using
it,
and
14
release
is
going
to
happen
next
month
and
it's
going
to
be
very
stable.
Anyways.
There.
D
D
E
F
D
Video
tablet
is
like
a
side
car
instance.
So,
basically,
if
you
want
to
send
a
query
like
vtr,
it
needs
to
some
some
way
to
like
start
replication
of
my
sequel.
Instead
of
querying
directly
to
mysql,
we
prefer
to
have
a
sidecar
instance.
Pd
tablet,
which
supports
grpc
protocol
and
few
other
things
that
you
can
use.
So
vtr
will
query
tablet
and
it'll,
and
the
wii
tablet
is
the
instance
that
will
run
it
on.
D
My
sql
same
goes
for
the
component,
so
it's
like
for
communication
purposes
for
other
things
for
like
getting
like
the
health
health
stream
as
to
video
tablet,
will
also
sell,
send
health
streams
to
mitigate
it's
like
for
registry
purposes.
For
all
of
those
things,
we
have
a
video
tablet,
sidecar,
it's
not
the
one
that
does
the
the
durability
things
that
actually
happens
through
the
btcple
and
the
durability
also
happens
directly
into
my
sequel.
D
So
you
have
a
primary
instance,
and
you
set
it
up
with
how
many
number
of
semi-sync
acts
you
require
for
it
to
make
progress,
and
that
is
the
number
that
is
how
you
use
the
durability
and
with
test
will
guarantee
that
when
you
do
the
failovers,
it
will
respect
the
durability
policy
that
you
set
right.
Does
that
answer
your
question?
Yeah?
Okay,
all
right!
C
A
So,
actually,
some
it's
a
community
basically
supported
by
a
community
right.
So
a
few
of
the
backups
that
it
already
supports
is
like
storage,
s3
and,
and
you
can
do
contributions
on
more
on
those
and
file
systems
and
stuff.
So,
and
you
have
to
just
give
in
in
the
vt
tablet
that
we
showed
the
sidecar.
That
will
take
those
inputs
that
where
you
want
to
store
the
backup
and
it
will,
it
will
use
that
information
to
do
the
backup.
A
E
C
F
G
A
F
G
D
No,
we
didn't,
we
didn't
split
the
traffic,
it
was
earlier
going
entirely
to
rds
and
at
one
point
we
switched
over
and
it
was
going
entirely
to
test.
You
can,
however,
split
the
traffic,
but
only
between
reads
and
writes,
so
you
can.
You
can
just
switch
the
reads
over
to
the
test.
First,
keep
the
rights
going
to
rds,
because
your
vstream
is
still
running
the
all
the
rights
that
go
to
rds
will
eventually
also
show
up
in
the
test,
so
you're
safe
there,
but
you
can
you
can
do
it
in
two
steps:
okay,
yeah.
D
A
A
G
A
E
H
B
D
You
didn't
do
the
complete
yeah,
so
first
you
have
everything
in
rds.
You
have
a
bit
test
on
top
of
rds.
Then
you
copied
everything
to
the
vitas
key
space.
At
that
point,
rds
is
still
running
our
data's
going
to
rds.
You
do
the
switch
traffic.
We
have
a
reverse
replication
stream
running,
which
means
that
any
data
that's
going
to
be
test
is
also
being
copied
over
to
rds.
Until
you
do
like
complete
everything
is
fine
and
you're
done
with
it.
We
won't
stop
sending
data
to
rds
too.
B
D
G
F
H
F
F
A
D
Those
errors
can
be
provided
and
sometimes
you'll
see
a
few
errors
that
we
saw
in
the
demo
when
we
start
buffering.
So
a
couple
of
errors
will
start
the
buffering
at
bt
gate
level,
and
then
it
will
start
buffering
all
those
requests,
and
you
won't
see
errors
further.
So
from
the
beginning,
the
errors
that
we
saw,
for
example,
that
I
had
to
take
down
the
rail
server
and
bring
it
back
up
again,
which
we
saw
like
10-15
years.
D
Yeah
any
any
planned
operation
through
the
test,
whether
it's
a
reshard,
so
it's
a
repair
or
a
move
tables
we
buffer
traffic
at
btk.
But
you
need
to
configure
the
buffer
pool
and
how
many
queries
you
want
to
buffer
at
a
time
because
you
could
have
like
out
of
memory
issues
if
you
buffer
too
much
right.
So
at
that
point
we
start.
We
stop
buffering
the
amount,
the
queries
that
are
old
and
we
start
throwing
errors
for
those.
B
A
A
B
A
D
You
mostly
it
should
yeah
most
of
the
query,
should
work
in
the
sharded
level
as
well,
so
example,
if
you
have
data
that
is
stored
in
two
different
charts
and
you're,
trying
to
join
that
also,
it
works
that
also
works.
We
have
an
evaluation
engine
at
the
vtgate
level.
That
will
do
those
things
for
you,
but
there
are
things
that
still
won't
work,
for
example,
window
window
functions
because
in
an
uncharted
mode
we
can
rely
on
mysql
to
do
that.
D
All
for
you,
like
we
can
just
spin
the
query
down
to
my
sql,
but
for
window
transaction
functions,
other
things
like
sharded
mode.
That
support
is
not
there,
but
evaluation
engine
is
the
primary
that
you
need
to
add
support
to.
So
if
there's
something
that
is
not
supported,
we
welcome
contributions
for
that
yeah.
G
So
if
you
tried
this
before
say
january
of
2021,
and
you
found
that
certain
things
didn't
work,
we've
actually
implemented
a
new
query.
Planner
called
gen4,
which
is
opt-in
right
now,
which
supports
a
lot
more
of
the
select
star
type
of
queries
with
sharded
mode
yeah,
so
select
start,
definitely
should
work.
E
D
B
A
I
I
A
A
B
F
G
A
E
A
A
So
if
you
do
count
star
on
some
table
right,
we
don't
do.
We
don't
select
all
the
rows
to
vt
gate.
What
we
do
is
we
push
down
that
query
down
to
the
mysql
level
to
do
the
counting
for
us,
and
we
just
do
the
summing
at
the
vtga
level,
so
our
engine
is
built
in
such
a
way
that
try
to
push
maximum
to
my
sequence,
because
it
knows
how
to
do
things.
It's
already
been
doing
for
so
long.
So
why
not?
And
then.